

<!DOCTYPE html>
<html lang="zh-CN" data-default-color-scheme=auto>



<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/blog/img/maple_leaf.png">
  <link rel="icon" href="/blog/img/maple_leaf.png">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=5.0, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="theme-color" content="#2f4154">
  <meta name="author" content="枫🍁川">
  <meta name="keywords" content="">
  
    <meta name="description" content="本文将从以下十一个维度为读者总结前端基础知识   JS基础1. 如何在ES5环境下实现let 这个问题实质上是在回答let和var有什么区别，对于这个问题，我们可以直接查看babel转换前后的结果，看一下在循环中通过let定义的变量是如何解决变量提升的问题    babel在let定义的变量前加了道下划线，避免在块级作用域外访问到该变量，除了对变量名的转换，我们也可以通过自执行函数来模拟块级作用">
<meta property="og:type" content="article">
<meta property="og:title" content="前端掌握知识程度">
<meta property="og:url" content="https://destiny-yyc.github.io/front-end.html">
<meta property="og:site_name" content="枫🍁川的博客">
<meta property="og:description" content="本文将从以下十一个维度为读者总结前端基础知识   JS基础1. 如何在ES5环境下实现let 这个问题实质上是在回答let和var有什么区别，对于这个问题，我们可以直接查看babel转换前后的结果，看一下在循环中通过let定义的变量是如何解决变量提升的问题    babel在let定义的变量前加了道下划线，避免在块级作用域外访问到该变量，除了对变量名的转换，我们也可以通过自执行函数来模拟块级作用">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/17150295c4bb639b~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714616e2fd53bf8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714fd86c8983189~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17149730709e41a4~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714980cac75fc32~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a1f7c054c657~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/5/17013323c225bd62~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a1d84ab05ba9~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a298b93c3208~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/1/28/16fec363208256b8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/1/16ffe7606c8db5e7~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/170097ce30734773~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/1700980f4879f2b8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/17009369c26da64b~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/1700962e1949c343~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714e043d3a1add2~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714ff9939df9d71~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17148debd6e97be5~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/2/1700388b88d9102c~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17148e2325d08c76~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714ffee2595a85c~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/171465b92f6ded5e~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="og:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714e0acba58457f~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
<meta property="article:published_time" content="2022-02-26T16:00:00.000Z">
<meta property="article:modified_time" content="2023-03-20T07:49:31.103Z">
<meta property="article:author" content="枫🍁川">
<meta property="article:tag" content="前端">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/17150295c4bb639b~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp">
  
  
    <meta name="referrer" content="no-referrer-when-downgrade">
  
  
  <title>前端掌握知识程度 - 枫🍁川的博客</title>

  <link  rel="stylesheet" href="https://lib.baomitu.com/twitter-bootstrap/4.6.1/css/bootstrap.min.css" />



  <link  rel="stylesheet" href="https://lib.baomitu.com/github-markdown-css/4.0.0/github-markdown.min.css" />

  <link  rel="stylesheet" href="https://lib.baomitu.com/hint.css/2.7.0/hint.min.css" />

  <link  rel="stylesheet" href="https://lib.baomitu.com/fancybox/3.5.7/jquery.fancybox.min.css" />



<!-- 主题依赖的图标库，不要自行修改 -->
<!-- Do not modify the link that theme dependent icons -->

<link rel="stylesheet" href="//at.alicdn.com/t/font_1749284_hj8rtnfg7um.css">



<link rel="stylesheet" href="//at.alicdn.com/t/font_1736178_lbnruvf0jn.css">


<link  rel="stylesheet" href="/blog/css/main.css" />


  <link id="highlight-css" rel="stylesheet" href="/blog/css/highlight.css" />
  
    <link id="highlight-css-dark" rel="stylesheet" href="/blog/css/highlight-dark.css" />
  




  <script id="fluid-configs">
    var Fluid = window.Fluid || {};
    Fluid.ctx = Object.assign({}, Fluid.ctx)
    var CONFIG = {"hostname":"destiny-yyc.github.io","root":"/blog/","version":"1.9.2","typing":{"enable":true,"typeSpeed":70,"cursorChar":"_","loop":false,"scope":[]},"anchorjs":{"enable":true,"element":"h1,h2,h3,h4,h5,h6","placement":"left","visible":"hover","icon":""},"progressbar":{"enable":true,"height_px":3,"color":"#29d","options":{"showSpinner":false,"trickleSpeed":100}},"code_language":{"enable":true,"default":"TEXT"},"copy_btn":true,"image_caption":{"enable":true},"image_zoom":{"enable":true,"img_url_replace":["",""]},"toc":{"enable":true,"placement":"right","headingSelector":"h1,h2,h3,h4,h5,h6","collapseDepth":0},"lazyload":{"enable":true,"loading_img":"/img/loading.gif","onlypost":false,"offset_factor":2},"web_analytics":{"enable":false,"follow_dnt":true,"baidu":null,"google":null,"gtag":null,"tencent":{"sid":null,"cid":null},"woyaola":null,"cnzz":null,"leancloud":{"app_id":null,"app_key":null,"server_url":null,"path":"window.location.pathname","ignore_local":false}},"search_path":"/blog/local-search.xml"};

    if (CONFIG.web_analytics.follow_dnt) {
      var dntVal = navigator.doNotTrack || window.doNotTrack || navigator.msDoNotTrack;
      Fluid.ctx.dnt = dntVal && (dntVal.startsWith('1') || dntVal.startsWith('yes') || dntVal.startsWith('on'));
    }
  </script>
  <script  src="/blog/js/utils.js" ></script>
  <script  src="/blog/js/color-schema.js" ></script>
  


  
<meta name="generator" content="Hexo 6.2.0"></head>


<body>
  

  <header>
    

<div class="header-inner" style="height: 70vh;">
  <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand" href="/blog/">
      <strong>枫🍁川的博客</strong>
    </a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/blog/archives/">
                <i class="iconfont icon-archive-fill"></i>
                归档
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/blog/categories/">
                <i class="iconfont icon-category-fill"></i>
                分类
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/blog/tags/">
                <i class="iconfont icon-tags-fill"></i>
                标签
              </a>
            </li>
          
        
          
          
          
          
            <li class="nav-item">
              <a class="nav-link" href="/blog/about/">
                <i class="iconfont icon-user-fill"></i>
                关于
              </a>
            </li>
          
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" target="_self" href="javascript:;" data-toggle="modal" data-target="#modalSearch" aria-label="Search">
              &nbsp;<i class="iconfont icon-search"></i>&nbsp;
            </a>
          </li>
          
        
        
          <li class="nav-item" id="color-toggle-btn">
            <a class="nav-link" target="_self" href="javascript:;" aria-label="Color Toggle">&nbsp;<i
                class="iconfont icon-dark" id="color-toggle-icon"></i>&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

  

<div id="banner" class="banner" parallax=true
     style="background: url('/blog/img/default.png') no-repeat center center; background-size: cover;">
  <div class="full-bg-img">
    <div class="mask flex-center" style="background-color: rgba(0, 0, 0, 0.3)">
      <div class="banner-text text-center fade-in-up">
        <div class="h2">
          
            <span id="subtitle" data-typed-text="前端掌握知识程度"></span>
          
        </div>

        
          
  <div class="mt-3">
    
      <span class="post-meta mr-2">
        <i class="iconfont icon-author" aria-hidden="true"></i>
        枫🍁川
      </span>
    
    
      <span class="post-meta">
        <i class="iconfont icon-date-fill" aria-hidden="true"></i>
        <time datetime="2022-02-27 00:00" pubdate>
          2022年2月27日
        </time>
      </span>
    
  </div>

  <div class="mt-1">
    
      <span class="post-meta mr-2">
        <i class="iconfont icon-chart"></i>
        
          34k 字
        
      </span>
    

    

    
    
  </div>


        
      </div>

      
    </div>
  </div>
</div>

</div>

  </header>

  <main>
    
      

<div class="container-fluid nopadding-x">
  <div class="row nomargin-x">
    <div class="side-col d-none d-lg-block col-lg-2">
      

    </div>

    <div class="col-lg-8 nopadding-x-md">
      <div class="container nopadding-x-md" id="board-ctn">
        <div id="board">
          <article class="post-content mx-auto">
            <!-- SEO header -->
            <h1 style="display: none">前端掌握知识程度</h1>
            
            
              <div class="markdown-body">
                
                <blockquote>
<p>本文将从以下十一个维度为读者总结前端基础知识</p>
</blockquote>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/17150295c4bb639b~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h1 id="JS基础"><a href="#JS基础" class="headerlink" title="JS基础"></a>JS基础</h1><h2 id="1-如何在ES5环境下实现let"><a href="#1-如何在ES5环境下实现let" class="headerlink" title="1. 如何在ES5环境下实现let"></a>1. 如何在ES5环境下实现let</h2><blockquote>
<p>这个问题实质上是在回答<code>let</code>和<code>var</code>有什么区别，对于这个问题，我们可以直接查看<code>babel</code>转换前后的结果，看一下在循环中通过<code>let</code>定义的变量是如何解决变量提升的问题</p>
</blockquote>
<p> <img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714616e2fd53bf8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p><code>babel</code>在<code>let</code>定义的变量前加了道下划线，避免在块级作用域外访问到该变量，除了对变量名的转换，我们也可以通过自执行函数来模拟块级作用域</p>
<div class="code-wrapper"><pre><code class="hljs javascript">(<span class="hljs-keyword">function</span>(<span class="hljs-params"></span>)&#123;
  <span class="hljs-keyword">for</span>(<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-number">5</span>; i ++)&#123;
    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(i)  <span class="hljs-comment">// 0 1 2 3 4 </span>
  &#125;
&#125;)();

<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(i)      <span class="hljs-comment">// Uncaught ReferenceError: i is not defined</span></code></pre></div>

<p>不过这个问题并没有结束，我们回到<code>var</code>和<code>let/const</code>的区别上：</p>
<ol>
<li><code>var</code>声明的变量会挂到window上，而<code>let</code>和<code>const</code>不会</li>
<li><code>var</code>声明的变量存在变量提升，而<code>let</code>和<code>const</code>不会</li>
<li><code>let</code>和<code>const</code>声明形成块作用域，只能在块作用域里访问，不能跨块访问，也不能跨函数访问</li>
<li>同一作用域下<code>let</code>和<code>const</code>不能声明同名变量，而<code>var</code>可以</li>
<li>暂时性死区，<code>let</code>和<code>const</code>声明的变量不能在声明前被使用</li>
</ol>
<p><code>babel</code>的转化，其实只实现了第2、3、5点</p>
<h2 id="2-如何在ES5环境下实现const"><a href="#2-如何在ES5环境下实现const" class="headerlink" title="2. 如何在ES5环境下实现const"></a>2. 如何在ES5环境下实现const</h2><p>实现const的关键在于<code>Object.defineProperty()</code>这个API，这个API用于在一个对象上增加或修改属性。通过配置属性描述符，可以精确地控制属性行为。<code>Object.defineProperty() </code>接收三个参数：</p>
<blockquote>
<p>Object.defineProperty(obj, prop, desc)</p>
</blockquote>
<table>
<thead>
<tr>
<th>参数</th>
<th>说明</th>
</tr>
</thead>
<tbody><tr>
<td>obj</td>
<td>要在其上定义属性的对象</td>
</tr>
<tr>
<td>prop</td>
<td>要定义或修改的属性的名称</td>
</tr>
<tr>
<td>descriptor</td>
<td>将被定义或修改的属性描述符</td>
</tr>
</tbody></table>
<table>
<thead>
<tr>
<th>属性描述符</th>
<th>说明</th>
<th>默认值</th>
</tr>
</thead>
<tbody><tr>
<td>value</td>
<td>该属性对应的值。可以是任何有效的 JavaScript 值（数值，对象，函数等）。默认为 undefined</td>
<td>undefined</td>
</tr>
<tr>
<td>get</td>
<td>一个给属性提供 getter 的方法，如果没有 getter 则为 undefined</td>
<td>undefined</td>
</tr>
<tr>
<td>set</td>
<td>一个给属性提供 setter 的方法，如果没有 setter 则为 undefined。当属性值修改时，触发执行该方法</td>
<td>undefined</td>
</tr>
<tr>
<td>writable</td>
<td>当且仅当该属性的writable为true时，value才能被赋值运算符改变。默认为 false</td>
<td>false</td>
</tr>
<tr>
<td>enumerable</td>
<td>enumerable定义了对象的属性是否可以在 for…in 循环和 Object.keys() 中被枚举</td>
<td>false</td>
</tr>
<tr>
<td>Configurable</td>
<td>configurable特性表示对象的属性是否可以被删除，以及除value和writable特性外的其他特性是否可以被修改</td>
<td>false</td>
</tr>
</tbody></table>
<p>对于<code>const</code>不可修改的特性，我们通过设置writable属性来实现</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">_const</span>(<span class="hljs-params">key, value</span>) &#123;    
    <span class="hljs-keyword">const</span> desc = &#123;        
        value,        
        <span class="hljs-attr">writable</span>: <span class="hljs-literal">false</span>    
    &#125;    
    <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">defineProperty</span>(<span class="hljs-variable language_">window</span>, key, desc)
&#125;
    
<span class="hljs-title function_">_const</span>(<span class="hljs-string">&#x27;obj&#x27;</span>, &#123;<span class="hljs-attr">a</span>: <span class="hljs-number">1</span>&#125;)   <span class="hljs-comment">//定义obj</span>
obj.<span class="hljs-property">b</span> = <span class="hljs-number">2</span>               <span class="hljs-comment">//可以正常给obj的属性赋值</span>
obj = &#123;&#125;                <span class="hljs-comment">//无法赋值新对象</span></code></pre></div>

<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://destiny-yyc.gitee.io/myblog/const-for-es5.html">如何在 ES5 环境下实现一个const?</a></p>
</blockquote>
<h2 id="3-手写call"><a href="#3-手写call" class="headerlink" title="3. 手写call()"></a>3. 手写call()</h2><blockquote>
<p><code>call() 方法</code>使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数<br>语法：<code>function.call(thisArg, arg1, arg2, ...)</code></p>
</blockquote>
<p><code>call()</code>的原理比较简单，由于函数的this指向它的直接调用者，我们变更调用者即完成this指向的变更：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">//变更函数调用者示例</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>)
&#125;

<span class="hljs-comment">// 测试</span>
<span class="hljs-keyword">const</span> obj = &#123;
    <span class="hljs-attr">name</span>: <span class="hljs-string">&#x27;写代码像蔡徐抻&#x27;</span>
&#125;
obj.<span class="hljs-property">foo</span> = foo   <span class="hljs-comment">// 变更foo的调用者</span>
obj.<span class="hljs-title function_">foo</span>()       <span class="hljs-comment">// &#x27;写代码像蔡徐抻&#x27;</span></code></pre></div>

<p>基于以上原理, 我们两句代码就能实现call()</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-title class_">Function</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">myCall</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">thisArg, ...args</span>) &#123;
    thisArg.<span class="hljs-property">fn</span> = <span class="hljs-variable language_">this</span>              <span class="hljs-comment">// this指向调用call的对象,即我们要改变this指向的函数</span>
    <span class="hljs-keyword">return</span> thisArg.<span class="hljs-title function_">fn</span>(...args)     <span class="hljs-comment">// 执行函数并return其执行结果</span>
&#125;</code></pre></div>

<p>但是我们有一些细节需要处理：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-title class_">Function</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">myCall</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">thisArg, ...args</span>) &#123;
    <span class="hljs-keyword">const</span> fn = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">&#x27;fn&#x27;</span>)        <span class="hljs-comment">// 声明一个独有的Symbol属性, 防止fn覆盖已有属性</span>
    thisArg = thisArg || <span class="hljs-variable language_">window</span>    <span class="hljs-comment">// 若没有传入this, 默认绑定window对象</span>
    thisArg[fn] = <span class="hljs-variable language_">this</span>              <span class="hljs-comment">// this指向调用call的对象,即我们要改变this指向的函数</span>
    <span class="hljs-keyword">const</span> result = thisArg[fn](...args)  <span class="hljs-comment">// 执行当前函数</span>
    <span class="hljs-keyword">delete</span> thisArg[fn]              <span class="hljs-comment">// 删除我们声明的fn属性</span>
    <span class="hljs-keyword">return</span> result                  <span class="hljs-comment">// 返回函数执行结果</span>
&#125;

<span class="hljs-comment">//测试</span>
foo.<span class="hljs-title function_">myCall</span>(obj)     <span class="hljs-comment">// 输出&#x27;写代码像蔡徐抻&#x27;</span></code></pre></div>

<h2 id="4-手写apply"><a href="#4-手写apply" class="headerlink" title="4. 手写apply()"></a>4. 手写apply()</h2><blockquote>
<p><code>apply()</code>方法调用一个具有给定this值的函数，以及作为一个数组（或类似数组对象）提供的参数。<br>语法：<code>func.apply(thisArg, [argsArray])</code></p>
</blockquote>
<p><code>apply()</code>和<code>call()</code>类似，区别在于<code>call()</code>接收参数列表，而<code>apply()</code>接收一个参数数组，所以我们在<code>call()</code>的实现上简单改一下入参形式即可</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-title class_">Function</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">myApply</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">thisArg, args</span>) &#123;
    <span class="hljs-keyword">const</span> fn = <span class="hljs-title class_">Symbol</span>(<span class="hljs-string">&#x27;fn&#x27;</span>)        <span class="hljs-comment">// 声明一个独有的Symbol属性, 防止fn覆盖已有属性</span>
    thisArg = thisArg || <span class="hljs-variable language_">window</span>    <span class="hljs-comment">// 若没有传入this, 默认绑定window对象</span>
    thisArg[fn] = <span class="hljs-variable language_">this</span>              <span class="hljs-comment">// this指向调用call的对象,即我们要改变this指向的函数</span>
    <span class="hljs-keyword">const</span> result = thisArg[fn](...args)  <span class="hljs-comment">// 执行当前函数（此处说明一下：虽然apply()接收的是一个数组，但在调用原函数时，依然要展开参数数组。可以对照原生apply()，原函数接收到展开的参数数组）</span>
    <span class="hljs-keyword">delete</span> thisArg[fn]              <span class="hljs-comment">// 删除我们声明的fn属性</span>
    <span class="hljs-keyword">return</span> result                  <span class="hljs-comment">// 返回函数执行结果</span>
&#125;

<span class="hljs-comment">//测试</span>
foo.<span class="hljs-title function_">myApply</span>(obj, [])     <span class="hljs-comment">// 输出&#x27;写代码像蔡徐抻&#x27;</span></code></pre></div>

<h2 id="5-手写bind"><a href="#5-手写bind" class="headerlink" title="5. 手写bind()"></a>5. 手写bind()</h2><blockquote>
<p><code>bind()</code>方法创建一个新的函数，在<code>bind()</code>被调用时，这个新函数的 this 被指定为<code>bind()</code>的第一个参数，而其余参数将作为新函数的参数，供调用时使用。<br>语法: <code>function.bind(thisArg, arg1, arg2, ...)</code></p>
</blockquote>
<p>从用法上看，似乎给<code>call/apply</code>包一层function就实现了<code>bind()</code>：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-title class_">Function</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">myBind</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params">thisArg, ...args</span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-function">() =&gt;</span> &#123;
        <span class="hljs-variable language_">this</span>.<span class="hljs-title function_">apply</span>(thisArg, args)
    &#125;
&#125;</code></pre></div>

<p>但我们忽略了三点：</p>
<ol>
<li><code>bind()</code>除了this还接收其他参数，<code>bind() </code>返回的函数也接收参数，这两部分的参数都要传给返回的函数</li>
<li>new会改变this指向：如果<code>bind</code>绑定后的函数被new了，那么this指向会发生改变，指向当前函数的实例</li>
<li>没有保留原函数在原型链上的属性和方法</li>
</ol>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-title class_">Function</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">myBind</span> = <span class="hljs-keyword">function</span> (<span class="hljs-params">thisArg, ...args</span>) &#123;
    <span class="hljs-keyword">var</span> self = <span class="hljs-variable language_">this</span>
    <span class="hljs-comment">// new优先级</span>
    <span class="hljs-keyword">var</span> fbound = <span class="hljs-keyword">function</span> (<span class="hljs-params"></span>) &#123;
        self.<span class="hljs-title function_">apply</span>(<span class="hljs-variable language_">this</span> <span class="hljs-keyword">instanceof</span> self ? <span class="hljs-variable language_">this</span> : thisArg, args.<span class="hljs-title function_">concat</span>(<span class="hljs-title class_">Array</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">slice</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">arguments</span>)))
    &#125;
    <span class="hljs-comment">// 继承原型上的属性和方法</span>
    fbound.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(self.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>);

		<span class="hljs-keyword">return</span> fbound;
&#125;

<span class="hljs-comment">//测试</span>
<span class="hljs-keyword">const</span> obj = &#123; <span class="hljs-attr">name</span>: <span class="hljs-string">&#x27;写代码像蔡徐抻&#x27;</span> &#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">foo</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>)
    <span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-variable language_">arguments</span>)
&#125;

foo.<span class="hljs-title function_">myBind</span>(obj, <span class="hljs-string">&#x27;a&#x27;</span>, <span class="hljs-string">&#x27;b&#x27;</span>, <span class="hljs-string">&#x27;c&#x27;</span>)()    <span class="hljs-comment">//输出写代码像蔡徐抻 [&#x27;a&#x27;, &#x27;b&#x27;, &#x27;c&#x27;]</span></code></pre></div>

<h2 id="6-手写一个防抖函数"><a href="#6-手写一个防抖函数" class="headerlink" title="6. 手写一个防抖函数"></a>6. 手写一个防抖函数</h2><p>防抖和节流的概念都比较简单，所以我们就不在“防抖节流是什么”这个问题上浪费过多篇幅了，简单点一下：</p>
<blockquote>
<p>防抖，即<code>短时间内大量触发同一事件，只会执行一次函数</code>，实现原理为<code>设置一个定时器，约定在xx毫秒后再触发事件处理，每次触发事件都会重新设置计时器，直到xx毫秒内无第二次操作</code>，防抖常用于搜索框&#x2F;滚动条的监听事件处理，如果不做防抖，每输入一个字&#x2F;滚动屏幕，都会触发事件处理，造成性能浪费。</p>
</blockquote>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">debounce</span>(<span class="hljs-params">func, wait</span>) &#123;
    <span class="hljs-keyword">let</span> timeout = <span class="hljs-literal">null</span>
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
        <span class="hljs-keyword">let</span> context = <span class="hljs-variable language_">this</span>
        <span class="hljs-keyword">let</span> args = <span class="hljs-variable language_">arguments</span>
        <span class="hljs-keyword">if</span> (timeout) <span class="hljs-built_in">clearTimeout</span>(timeout)
        timeout = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =&gt;</span> &#123;
            func.<span class="hljs-title function_">apply</span>(context, args)
        &#125;, wait)
    &#125;
&#125;</code></pre></div>

<h2 id="7-手写一个节流函数"><a href="#7-手写一个节流函数" class="headerlink" title="7. 手写一个节流函数"></a>7. 手写一个节流函数</h2><blockquote>
<p>防抖是<code>延迟执行</code>，而节流是<code>间隔执行 </code>，函数节流<code>即每隔一段时间就执行一次</code>，实现原理为<code>设置一个定时器，约定xx毫秒后执行事件，如果时间到了，那么执行函数并重置定时器</code>，和防抖的区别在于，防抖每次触发事件都重置定时器，而节流在定时器到时间后再清空定时器</p>
</blockquote>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">throttle</span>(<span class="hljs-params">func, wait</span>) &#123;
    <span class="hljs-keyword">let</span> timeout = <span class="hljs-literal">null</span>
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
        <span class="hljs-keyword">let</span> context = <span class="hljs-variable language_">this</span>
        <span class="hljs-keyword">let</span> args = <span class="hljs-variable language_">arguments</span>
        <span class="hljs-keyword">if</span> (!timeout) &#123;
            timeout = <span class="hljs-built_in">setTimeout</span>(<span class="hljs-function">() =&gt;</span> &#123;
                timeout = <span class="hljs-literal">null</span>
                func.<span class="hljs-title function_">apply</span>(context, args)
            &#125;, wait)
        &#125;
		&#125;
&#125;</code></pre></div>

<blockquote>
<p>实现方式2：使用两个时间戳<code>prev旧时间戳</code>和<code>now新时间戳</code>，每次触发事件都判断二者的时间差，如果到达规定时间，执行函数并重置旧时间戳</p>
</blockquote>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">throttle</span>(<span class="hljs-params">func, wait</span>) &#123;
    <span class="hljs-keyword">var</span> prev = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
        <span class="hljs-keyword">let</span> now = <span class="hljs-title class_">Date</span>.<span class="hljs-title function_">now</span>();
        <span class="hljs-keyword">let</span> context = <span class="hljs-variable language_">this</span>;
        <span class="hljs-keyword">let</span> args = <span class="hljs-variable language_">arguments</span>;
        <span class="hljs-keyword">if</span> (now - prev &gt; wait) &#123;
            func.<span class="hljs-title function_">apply</span>(context, args);
            prev = now;
        &#125;
    &#125;
&#125;</code></pre></div>

<h2 id="8-数组扁平化"><a href="#8-数组扁平化" class="headerlink" title="8. 数组扁平化"></a>8. 数组扁平化</h2><blockquote>
<p>对于<code>[1, [1,2], [1,2,3]]</code>这样多层嵌套的数组，我们如何将其扁平化为<code>[1, 1, 2, 1, 2, 3]</code>]这样的一维数组呢：</p>
</blockquote>
<h3 id="1-ES6的flat"><a href="#1-ES6的flat" class="headerlink" title="1. ES6的flat()"></a><strong>1. ES6的flat()</strong></h3><div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">const</span> arr = [<span class="hljs-number">1</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>], [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]]
arr.<span class="hljs-title function_">flat</span>(<span class="hljs-title class_">Infinity</span>)  <span class="hljs-comment">// [1, 1, 2, 1, 2, 3]</span></code></pre></div>

<h3 id="2-序列化后正则"><a href="#2-序列化后正则" class="headerlink" title="2. 序列化后正则"></a><strong>2. 序列化后正则</strong></h3><div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">const</span> arr = [<span class="hljs-number">1</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>], [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]]
<span class="hljs-keyword">const</span> str = <span class="hljs-string">`[<span class="hljs-subst">$&#123;<span class="hljs-built_in">JSON</span>.stringify(arr).replace(/(\[|\])/g, <span class="hljs-string">&#x27;&#x27;</span>)&#125;</span>]`</span>
<span class="hljs-title class_">JSON</span>.<span class="hljs-title function_">parse</span>(str)   <span class="hljs-comment">// [1, 1, 2, 1, 2, 3]</span></code></pre></div>

<h3 id="3-递归"><a href="#3-递归" class="headerlink" title="3. 递归"></a><strong>3. 递归</strong></h3><p>对于树状结构的数据，最直接的处理方式就是递归</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">const</span> arr = [<span class="hljs-number">1</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>], [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]]
<span class="hljs-keyword">function</span> <span class="hljs-title function_">flat</span>(<span class="hljs-params">arr</span>) &#123;
  <span class="hljs-keyword">let</span> result = []
  <span class="hljs-keyword">for</span> (<span class="hljs-keyword">const</span> item <span class="hljs-keyword">of</span> arr) &#123;
    item <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">Array</span> ? result = result.<span class="hljs-title function_">concat</span>(<span class="hljs-title function_">flat</span>(item)) : result.<span class="hljs-title function_">push</span>(item)
  &#125;
  <span class="hljs-keyword">return</span> result
&#125;

<span class="hljs-title function_">flat</span>(arr) <span class="hljs-comment">// [1, 1, 2, 1, 2, 3]</span></code></pre></div>

<h3 id="4-reduce-递归"><a href="#4-reduce-递归" class="headerlink" title="4. reduce()递归"></a><strong>4. reduce()递归</strong></h3><div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">const</span> arr = [<span class="hljs-number">1</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>], [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]]
<span class="hljs-keyword">function</span> <span class="hljs-title function_">flat</span>(<span class="hljs-params">arr</span>) &#123;
  <span class="hljs-keyword">return</span> arr.<span class="hljs-title function_">reduce</span>(<span class="hljs-function">(<span class="hljs-params">prev, cur</span>) =&gt;</span> &#123;
    <span class="hljs-keyword">return</span> prev.<span class="hljs-title function_">concat</span>(cur <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">Array</span> ? <span class="hljs-title function_">flat</span>(cur) : cur)
  &#125;, [])
&#125;

<span class="hljs-title function_">flat</span>(arr)  <span class="hljs-comment">// [1, 1, 2, 1, 2, 3]</span></code></pre></div>

<h3 id="5-迭代-展开运算符"><a href="#5-迭代-展开运算符" class="headerlink" title="5.迭代+展开运算符"></a><strong>5.迭代+展开运算符</strong></h3><div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">// 每次while都会合并一层的元素，这里第一次合并结果为[1, 1, 2, 1, 2, 3, [4,4,4]]</span>
<span class="hljs-comment">// 然后arr.some判定数组中是否存在数组，因为存在[4,4,4]，继续进入第二次循环进行合并</span>
<span class="hljs-keyword">let</span> arr = [<span class="hljs-number">1</span>, [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>], [<span class="hljs-number">1</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>,[<span class="hljs-number">4</span>,<span class="hljs-number">4</span>,<span class="hljs-number">4</span>]]]
<span class="hljs-keyword">while</span> (arr.<span class="hljs-title function_">some</span>(<span class="hljs-title class_">Array</span>.<span class="hljs-property">isArray</span>)) &#123;
  arr = [].<span class="hljs-title function_">concat</span>(...arr);
&#125;

<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(arr)  <span class="hljs-comment">// [1, 1, 2, 1, 2, 3, 4, 4, 4]</span></code></pre></div>

<h2 id="9-手写一个Promise"><a href="#9-手写一个Promise" class="headerlink" title="9. 手写一个Promise"></a>9. 手写一个Promise</h2><blockquote>
<p>实现一个符合规范的Promise篇幅比较长，建议阅读笔者上一篇文章：异步编程二三事 | Promise&#x2F;async&#x2F;Generator实现原理解析 | 9k字</p>
</blockquote>
<h1 id="JS面向对象"><a href="#JS面向对象" class="headerlink" title="JS面向对象"></a>JS面向对象</h1><p>在JS中一切皆对象，但JS并不是一种真正的面向对象(OOP)的语言，因为它缺少<code>var</code>的概念。虽然ES6引入了<code>class</code>和<code>extends</code>，使我们能够轻易地实现类和继承。但JS并不存在真实的类，JS的类是通过函数以及原型链机制模拟的，本小节的就来探究如何在ES5环境下利用函数和原型链实现JS面向对象的特性</p>
<p>在开始之前，我们先回顾一下原型链的知识，后续<code>new</code>和<code>继承</code>等实现都是基于原型链机制。很多介绍原型链的资料都能写上洋洋洒洒几千字，但我觉得读者们不需要把原型链想太复杂，容易把自己绕进去，其实在我看来，原型链的核心只需要记住三点：</p>
<ol>
<li><p>每个对象都有<code>new</code>属性，该属性指向其原型对象，在调用实例的方法和属性时，如果在实例对象上找不到，就会往原型对象上找</p>
</li>
<li><p>构造函数的<code>prototype属性</code>也指向实例的原型对象</p>
</li>
<li><p>原型对象的<code>constructor属性</code>指向构造函数</p>
</li>
</ol>
<h2 id="1-模拟实现new"><a href="#1-模拟实现new" class="headerlink" title="1. 模拟实现new"></a>1. 模拟实现new</h2><blockquote>
<p>首先我们要知道<code>new</code>做了什么</p>
</blockquote>
<ol>
<li><strong>创建一个新对象，并继承其构造函数的<code>prototype</code>，</strong>这一步是为了继承构造函数原型上的属性和方法</li>
<li><strong>执行构造函数，方法内的<code>this</code>被指定为该新实例</strong>，这一步是为了执行构造函数内的赋值操作</li>
<li><strong>返回新实例</strong>（规范规定，如果构造方法返回了一个对象，那么返回该对象，否则返回第一步创建的新对象）</li>
</ol>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">// new是关键字,这里我们用函数来模拟,new Foo(args) &lt;=&gt; myNew(Foo, args)</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">myNew</span>(<span class="hljs-params">foo, ...args</span>) &#123;
  <span class="hljs-comment">// 创建新对象,并继承构造方法的prototype属性, 这一步是为了把obj挂原型链上, 相当于obj.__proto__ = Foo.prototype</span>
  <span class="hljs-keyword">let</span> obj = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(foo.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>)  

  <span class="hljs-comment">// 执行构造方法, 并为其绑定新this, 这一步是为了让构造方法能进行this.name = name之类的操作, args是构造方法的入参, 因为这里用myNew模拟, 所以入参从myNew传入</span>
  <span class="hljs-keyword">let</span> result = foo.<span class="hljs-title function_">apply</span>(obj, args)

  <span class="hljs-comment">// 如果构造方法已经return了一个对象，那么就返回该对象，否则返回myNew创建的新对象（一般情况下，构造方法不会返回新实例，但使用者可以选择返回新实例来覆盖new创建的对象）</span>
  <span class="hljs-keyword">return</span> <span class="hljs-title class_">Object</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">toString</span>.<span class="hljs-title function_">call</span>(result) === <span class="hljs-string">&#x27;[object Object]&#x27;</span> ? result : obj
&#125;

<span class="hljs-comment">// 测试：</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Foo</span>(<span class="hljs-params">name</span>) &#123;
  <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = name
&#125;
<span class="hljs-keyword">const</span> newObj = <span class="hljs-title function_">myNew</span>(<span class="hljs-title class_">Foo</span>, <span class="hljs-string">&#x27;zhangsan&#x27;</span>)
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newObj)                 <span class="hljs-comment">// Foo &#123;name: &quot;zhangsan&quot;&#125;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(newObj <span class="hljs-keyword">instanceof</span> <span class="hljs-title class_">Foo</span>)  <span class="hljs-comment">// true</span></code></pre></div>

<h2 id="2-ES5如何实现继承"><a href="#2-ES5如何实现继承" class="headerlink" title="2. ES5如何实现继承"></a>2. ES5如何实现继承</h2><blockquote>
<p>说到继承，最容易想到的是ES6的extends，当然如果只回答这个肯定不合格，我们要从函数和原型链的角度上实现继承，下面我们一步步地、递进地实现一个合格的继承</p>
</blockquote>
<h3 id="一-原型链继承"><a href="#一-原型链继承" class="headerlink" title="一. 原型链继承"></a>一. 原型链继承</h3><p>原型链继承的原理很简单，直接让子类的原型对象指向父类实例，当子类实例找不到对应的属性和方法时，就会往它的原型对象，也就是父类实例上找，从而实现对父类的属性和方法的继承</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">// 父类</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params"></span>) &#123;
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = <span class="hljs-string">&#x27;写代码像蔡徐抻&#x27;</span>
&#125;
<span class="hljs-comment">// 父类的原型方法</span>
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
 <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-comment">// 子类</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;&#125;

<span class="hljs-comment">// 让子类的原型对象指向父类实例, 这样一来在Child实例中找不到的属性和方法就会到原型对象(父类实例)上寻找</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Parent</span>()
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">constructor</span> = <span class="hljs-title class_">Child</span> <span class="hljs-comment">// 根据原型链的规则,顺便绑定一下constructor, 这一步不影响继承, 只是在用到constructor时会需要</span>

<span class="hljs-comment">// 然后Child实例就能访问到父类及其原型上的name属性和getName()方法</span>
<span class="hljs-keyword">const</span> child = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
child.<span class="hljs-property">name</span>          <span class="hljs-comment">// &#x27;写代码像蔡徐抻&#x27;</span>
child.<span class="hljs-title function_">getName</span>()     <span class="hljs-comment">// &#x27;写代码像蔡徐抻&#x27;</span></code></pre></div>

<p>原型继承的缺点:</p>
<ol>
<li>由于所有Child实例原型都指向同一个Parent实例, 因此对某个Child实例的父类引用类型变量修改会影响所有的Child实例</li>
<li>在创建子类实例时无法向父类构造传参, 即没有实现<code>super()</code>的功能</li>
</ol>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">// 示例:</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = [<span class="hljs-string">&#x27;写代码像蔡徐抻&#x27;</span>] 
&#125;
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;&#125;

<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Parent</span>()
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">constructor</span> = <span class="hljs-title class_">Child</span> 

<span class="hljs-comment">// 测试</span>
<span class="hljs-keyword">const</span> child1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
<span class="hljs-keyword">const</span> child2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
child1.<span class="hljs-property">name</span>[<span class="hljs-number">0</span>] = <span class="hljs-string">&#x27;foo&#x27;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child1.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;foo&#x27;]</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child2.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;foo&#x27;] (预期是[&#x27;写代码像蔡徐抻&#x27;], 对child1.name的修改引起了所有child实例的变化)</span></code></pre></div>

<h3 id="二-构造函数继承"><a href="#二-构造函数继承" class="headerlink" title="二. 构造函数继承"></a>二. 构造函数继承</h3><p>构造函数继承，即在子类的构造函数中执行父类的构造函数，并为其绑定子类的<code>this</code>，让父类的构造函数把成员属性和方法都挂到<code>子类的this</code>上去，这样既能避免实例之间共享一个原型实例，又能向父类构造方法传参</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params">name</span>) &#123;
    <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = [name]
&#125;
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-title class_">Parent</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-string">&#x27;zhangsan&#x27;</span>)   <span class="hljs-comment">// 执行父类构造方法并绑定子类的this, 使得父类中的属性能够赋到子类的this上</span>
&#125;

<span class="hljs-comment">//测试</span>
<span class="hljs-keyword">const</span> child1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
<span class="hljs-keyword">const</span> child2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
child1.<span class="hljs-property">name</span>[<span class="hljs-number">0</span>] = <span class="hljs-string">&#x27;foo&#x27;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child1.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;foo&#x27;]</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child2.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span>
child2.<span class="hljs-title function_">getName</span>()                  <span class="hljs-comment">// 报错,找不到getName(), 构造函数继承的方式继承不到父类原型上的属性和方法</span></code></pre></div>

<p>构造函数继承的缺点:</p>
<ol>
<li>继承不到父类原型上的属性和方法</li>
</ol>
<h3 id="三-组合式继承"><a href="#三-组合式继承" class="headerlink" title="三. 组合式继承"></a>三. 组合式继承</h3><p>既然原型链继承和构造函数继承各有互补的优缺点, 那么我们为什么不组合起来使用呢, 所以就有了综合二者的组合式继承</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params">name</span>) &#123;
    <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = [name]
&#125;
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-comment">// 构造函数继承</span>
    <span class="hljs-title class_">Parent</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-string">&#x27;zhangsan&#x27;</span>) 
&#125;
<span class="hljs-comment">//原型链继承</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Parent</span>()
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">constructor</span> = <span class="hljs-title class_">Child</span>

<span class="hljs-comment">//测试</span>
<span class="hljs-keyword">const</span> child1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
<span class="hljs-keyword">const</span> child2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
child1.<span class="hljs-property">name</span>[<span class="hljs-number">0</span>] = <span class="hljs-string">&#x27;foo&#x27;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child1.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;foo&#x27;]</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child2.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span>
child2.<span class="hljs-title function_">getName</span>()                  <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span></code></pre></div>

<p>组合式继承的缺点:</p>
<ol>
<li>每次创建子类实例都执行了两次构造函数(<code>new</code>和<code>new Parent()</code>)，虽然这并不影响对父类的继承，但子类创建实例时，原型中会存在两份相同的属性和方法，这并不优雅</li>
</ol>
<h3 id="四-寄生式组合继承"><a href="#四-寄生式组合继承" class="headerlink" title="四. 寄生式组合继承"></a>四. 寄生式组合继承</h3><p>为了解决构造函数被执行两次的问题, 我们将<code>指向父类实例</code>改为<code>指向父类原型</code>, 减去一次构造函数的执行</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params">name</span>) &#123;
    <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = [name]
&#125;
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-comment">// 构造函数继承</span>
    <span class="hljs-title class_">Parent</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-string">&#x27;zhangsan&#x27;</span>) 
&#125;
<span class="hljs-comment">//原型链继承</span>
<span class="hljs-comment">// Child.prototype = new Parent()</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>  <span class="hljs-comment">//将`指向父类实例`改为`指向父类原型`</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">constructor</span> = <span class="hljs-title class_">Child</span>

<span class="hljs-comment">//测试</span>
<span class="hljs-keyword">const</span> child1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
<span class="hljs-keyword">const</span> child2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
child1.<span class="hljs-property">name</span>[<span class="hljs-number">0</span>] = <span class="hljs-string">&#x27;foo&#x27;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child1.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;foo&#x27;]</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(child2.<span class="hljs-property">name</span>)          <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span>
child2.<span class="hljs-title function_">getName</span>()                  <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span></code></pre></div>

<p>但这种方式存在一个问题，由于子类原型和父类原型指向同一个对象，我们对子类原型的操作会影响到父类原型，例如给<code>Child.prototype</code>增加一个<code>getName()</code>方法，那么会导致<code>Parent.prototype</code>也增加或被覆盖一个<code>getName()</code>方法，为了解决这个问题，我们给<code>Parent.prototype</code>做一个浅拷贝</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">Parent</span>(<span class="hljs-params">name</span>) &#123;
    <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = [name]
&#125;
<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">getName</span> = <span class="hljs-keyword">function</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span>
&#125;
<span class="hljs-keyword">function</span> <span class="hljs-title function_">Child</span>(<span class="hljs-params"></span>) &#123;
    <span class="hljs-comment">// 构造函数继承</span>
    <span class="hljs-title class_">Parent</span>.<span class="hljs-title function_">call</span>(<span class="hljs-variable language_">this</span>, <span class="hljs-string">&#x27;zhangsan&#x27;</span>) 
&#125;
<span class="hljs-comment">//原型链继承</span>
<span class="hljs-comment">// Child.prototype = new Parent()</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span> = <span class="hljs-title class_">Object</span>.<span class="hljs-title function_">create</span>(<span class="hljs-title class_">Parent</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>)  <span class="hljs-comment">//将`指向父类实例`改为`指向父类原型`</span>
<span class="hljs-title class_">Child</span>.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">constructor</span> = <span class="hljs-title class_">Child</span>

<span class="hljs-comment">//测试</span>
<span class="hljs-keyword">const</span> child = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Child</span>()
<span class="hljs-keyword">const</span> parent = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Parent</span>()
child.<span class="hljs-title function_">getName</span>()                  <span class="hljs-comment">// [&#x27;zhangsan&#x27;]</span>
parent.<span class="hljs-title function_">getName</span>()                 <span class="hljs-comment">// 报错, 找不到getName()</span></code></pre></div>

<p>到这里我们就完成了ES5环境下的继承的实现，这种继承方式称为<code>寄生组合式继承</code>，是目前最成熟的继承方式，babel对ES6继承的转化也是使用了寄生组合式继承</p>
<p>我们回顾一下实现过程：<br>一开始最容易想到的是<code>原型链继承</code>，通过把子类实例的原型指向父类实例来继承父类的属性和方法，但原型链继承的缺陷在于<code>对子类实例继承的引用类型的修改会影响到所有的实例对象</code>以及<code>无法向父类的构造方法传参</code>。<br>因此我们引入了<code>构造函数继承</code>, 通过在子类构造函数中调用父类构造函数并传入子类this来获取父类的属性和方法，但构造函数继承也存在缺陷，构造函数继承<code>不能继承到父类原型链上的属性和方法</code>。<br>所以我们综合了两种继承的优点，提出了<code>组合式继承</code>，但组合式继承也引入了新的问题，它<code>每次创建子类实例都执行了两次父类构造方法</code>，我们通过将<code>子类原型指向父类实例</code>改为<code>子类原型指向父类原型的浅拷贝</code>来解决这一问题，也就是最终实现 —— <code>寄生组合式继承</code></p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714fd86c8983189~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h1 id="V8引擎机制"><a href="#V8引擎机制" class="headerlink" title="V8引擎机制"></a>V8引擎机制</h1><h2 id="1-V8如何执行一段JS代码"><a href="#1-V8如何执行一段JS代码" class="headerlink" title="1. V8如何执行一段JS代码"></a>1. V8如何执行一段JS代码</h2><ol>
<li><strong>预解析</strong>：检查语法错误但不生成AST</li>
<li><strong>生成AST</strong>：经过词法&#x2F;语法分析，生成抽象语法树</li>
<li><strong>生成字节码</strong>：基线编译器(Ignition)将AST转换成字节码</li>
<li><strong>生成机器码</strong>：优化编译器(Turbofan)将字节码转换成优化过的机器码，此外在逐行执行字节码的过程中，如果一段代码经常被执行，那么V8会将这段代码直接转换成机器码保存起来，下一次执行就不必经过字节码，优化了执行速度</li>
</ol>
<p>上面几点只是V8执行机制的极简总结，建议阅读参考资料：</p>
<blockquote>
<p>1.<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903990073753613">V8 是怎么跑起来的 —— V8 的 JavaScript 执行管道</a><br>2.<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844904021451505677">JavaScript 引擎 V8 执行流程概述</a></p>
</blockquote>
<h2 id="2-介绍一下引用计数和标记清除"><a href="#2-介绍一下引用计数和标记清除" class="headerlink" title="2. 介绍一下引用计数和标记清除"></a>2. 介绍一下引用计数和标记清除</h2><ul>
<li><p>引用计数：给一个变量赋值引用类型，则该对象的引用次数+1，如果这个变量变成了其他值，那么该对象的引用次数-1，垃圾回收器会回收引用次数为0的对象。但是当对象循环引用时，会导致引用次数永远无法归零，造成内存无法释放。</p>
</li>
<li><p>标记清除：垃圾收集器先给内存中所有对象加上标记，然后从根节点开始遍历，去掉被引用的对象和运行环境中对象的标记，剩下的被标记的对象就是无法访问的等待回收的对象。</p>
</li>
</ul>
<h2 id="3-V8如何进行垃圾回收"><a href="#3-V8如何进行垃圾回收" class="headerlink" title="3. V8如何进行垃圾回收"></a>3. V8如何进行垃圾回收</h2><p>JS引擎中对变量的存储主要有两种位置，栈内存和堆内存，栈内存存储基本类型数据以及引用类型数据的内存地址，堆内存储存引用类型的数据</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17149730709e41a4~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p><strong>栈内存的回收：</strong></p>
<p>栈内存调用栈上下文切换后就被回收，比较简单</p>
<p><strong>堆内存的回收：</strong></p>
<p>V8的堆内存分为新生代内存和老生代内存，新生代内存是临时分配的内存，存在时间短，老生代内存存在时间长<img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714980cac75fc32~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<ul>
<li><p>新生代内存回收机制：</p>
<ul>
<li>新生代内存容量小，64位系统下仅有32M。新生代内存分为From、To两部分，进行垃圾回收时，先扫描From，将非存活对象回收，将存活对象顺序复制到To中，之后调换From&#x2F;To，等待下一次回收</li>
</ul>
</li>
<li><p>老生代内存回收机制</p>
<ul>
<li><strong>晋升</strong>：如果新生代的变量经过多次回收依然存在，那么就会被放入老生代内存中<br><strong>标记清除</strong>：老生代内存会先遍历所有对象并打上标记，然后对正在使用或被强引用的对象取消标记，回收被标记的对象<br><strong>整理内存碎片</strong>：把对象挪到内存的一端</li>
</ul>
</li>
</ul>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a1f7c054c657~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903591510016007#heading-10">聊聊V8引擎的垃圾回收</a></p>
</blockquote>
<h2 id="4-JS相较于C-等语言为什么慢，V8做了哪些优化"><a href="#4-JS相较于C-等语言为什么慢，V8做了哪些优化" class="headerlink" title="4. JS相较于C++等语言为什么慢，V8做了哪些优化"></a>4. JS相较于C++等语言为什么慢，V8做了哪些优化</h2><ul>
<li><p>JS的问题：</p>
<ul>
<li><p><strong>动态类型</strong>：导致每次存取属性&#x2F;寻求方法时候，都需要先检查类型；此外动态类型也很难在编译阶段进行优化</p>
</li>
<li><p><strong>属性存取</strong>：C++&#x2F;Java等语言中方法、属性是存储在数组中的，仅需数组位移就可以获取，而JS存储在对象中，每次获取都要进行哈希查询</p>
</li>
</ul>
</li>
<li><p>V8的优化：</p>
<ul>
<li><p>**优化JIT(即时编译)**：相较于C++&#x2F;Java这类编译型语言，JS一边解释一边执行，效率低。V8对这个过程进行了优化：如果一段代码被执行多次，那么V8会把这段代码转化为机器码缓存下来，下次运行时直接使用机器码。</p>
</li>
<li><p><strong>隐藏类</strong>：对于C++这类语言来说，仅需几个指令就能通过偏移量获取变量信息，而JS需要进行字符串匹配，效率低，V8借用了类和偏移位置的思想，将对象划分成不同的组，即隐藏类</p>
</li>
<li><p><strong>内嵌缓存</strong>：即缓存对象查询的结果。常规查询过程是：获取隐藏类地址 -&gt; 根据属性名查找偏移值 -&gt; 计算该属性地址，内嵌缓存就是对这一过程结果的缓存</p>
</li>
<li><p>垃圾回收管理：上文已介绍</p>
</li>
</ul>
</li>
</ul>
<blockquote>
<p>参考资料：<a href="https://link.juejin.cn/?target=https://zhuanlan.zhihu.com/p/27628685">为什么V8引擎这么快？</a></p>
</blockquote>
<h1 id="浏览器渲染机制"><a href="#浏览器渲染机制" class="headerlink" title="浏览器渲染机制"></a>浏览器渲染机制</h1><h2 id="1-浏览器的渲染过程是怎样的"><a href="#1-浏览器的渲染过程是怎样的" class="headerlink" title="1. 浏览器的渲染过程是怎样的"></a>1. 浏览器的渲染过程是怎样的</h2><p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/5/17013323c225bd62~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>大体流程如下：</p>
<ol>
<li><p>HTML和CSS经过各自解析，生成DOM树和CSSOM树</p>
</li>
<li><p>合并成为渲染树</p>
</li>
<li><p>根据渲染树进行布局</p>
</li>
<li><p>最后调用GPU进行绘制，显示在屏幕上</p>
</li>
</ol>
<h2 id="2-如何根据浏览器渲染机制加快首屏速度"><a href="#2-如何根据浏览器渲染机制加快首屏速度" class="headerlink" title="2. 如何根据浏览器渲染机制加快首屏速度"></a>2. 如何根据浏览器渲染机制加快首屏速度</h2><ol>
<li><p>优化文件大小：HTML和CSS的加载和解析都会阻塞渲染树的生成，从而影响首屏展示速度，因此我们可以通过优化文件大小、减少CSS文件层级的方法来加快首屏速度</p>
</li>
<li><p>避免资源下载阻塞文档解析：浏览器解析到<code>&lt;script&gt;</code>标签时，会阻塞文档解析，直到脚本执行完成，因此我们通常<code>&lt;script&gt;</code>标签放在底部，或者加上<code>defer</code>、<code>async</code>来进行异步下载</p>
</li>
</ol>
<h2 id="3-什么是回流-重排-，什么情况下会触发回流"><a href="#3-什么是回流-重排-，什么情况下会触发回流" class="headerlink" title="3. 什么是回流(重排)，什么情况下会触发回流"></a>3. 什么是回流(重排)，什么情况下会触发回流</h2><ul>
<li><p>当元素的尺寸或者位置发生了变化，就需要重新计算渲染树，这就是回流</p>
</li>
<li><p>DOM元素的几何属性(<code>width/height/padding/margin/border</code>)发生变化时会触发回流</p>
</li>
<li><p>DOM元素移动或增加会触发回流</p>
</li>
<li><p>读写<code>offset/scroll/client</code>等属性时会触发回流</p>
</li>
<li><p>调用<code>window.getComputedStyle</code>会触发回流</p>
</li>
</ul>
<h2 id="4-什么是重绘，什么情况下会触发重绘"><a href="#4-什么是重绘，什么情况下会触发重绘" class="headerlink" title="4. 什么是重绘，什么情况下会触发重绘"></a>4. 什么是重绘，什么情况下会触发重绘</h2><ul>
<li>DOM样式发生了变化，但没有影响DOM的几何属性时，会触发重绘，而不会触发回流。重绘由于DOM位置信息不需要更新，省去了布局过程，因而性能上优于回流</li>
</ul>
<h2 id="5-什么是GPU加速，如何使用GPU加速，GPU加速的缺点"><a href="#5-什么是GPU加速，如何使用GPU加速，GPU加速的缺点" class="headerlink" title="5. 什么是GPU加速，如何使用GPU加速，GPU加速的缺点"></a>5. 什么是GPU加速，如何使用GPU加速，GPU加速的缺点</h2><ul>
<li><strong>优点</strong>：使用transform、opacity、filters等属性时，会直接在GPU中完成处理，这些属性的变化不会引起回流重绘</li>
<li><strong>缺点</strong>：GPU渲染字体会导致字体模糊，过多的GPU处理会导致内存问题</li>
</ul>
<h2 id="6-如何减少回流"><a href="#6-如何减少回流" class="headerlink" title="6. 如何减少回流"></a>6. 如何减少回流</h2><ul>
<li>使用<code>class</code>替代<code>style</code>，减少style的使用</li>
<li>使用<code>resize</code>、<code>scroll</code>时进行防抖和节流处理，这两者会直接导致回流</li>
<li>使用<code>visibility</code>替换<code>display: none</code>，因为前者只会引起重绘，后者会引发回流</li>
<li>批量修改元素时，可以先让元素脱离文档流，等修改完毕后，再放入文档流</li>
<li>避免触发同步布局事件，我们在获取<code>offsetWidth</code>这类属性的值时，可以使用变量将查询结果存起来，避免多次查询，每次对<code>offset/scroll/client</code>等属性进行查询时都会触发回流</li>
<li>对于复杂动画效果,使用绝对定位让其脱离文档流，复杂的动画效果会频繁地触发回流重绘，我们可以将动画元素设置绝对定位从而脱离文档流避免反复回流重绘。</li>
</ul>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a1d84ab05ba9~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903846834094094">必须明白的浏览器渲染机制</a></p>
</blockquote>
<h1 id="浏览器缓存策略"><a href="#浏览器缓存策略" class="headerlink" title="浏览器缓存策略"></a>浏览器缓存策略</h1><h2 id="1-介绍一下浏览器缓存位置和优先级"><a href="#1-介绍一下浏览器缓存位置和优先级" class="headerlink" title="1. 介绍一下浏览器缓存位置和优先级"></a>1. 介绍一下浏览器缓存位置和优先级</h2><ol>
<li>Service Worker</li>
<li>Memory Cache（内存缓存）</li>
<li>Disk Cache（硬盘缓存）</li>
<li>Push Cache（推送缓存）</li>
<li>以上缓存都没命中就会进行网络请求</li>
</ol>
<h2 id="2-说说不同缓存间的差别"><a href="#2-说说不同缓存间的差别" class="headerlink" title="2. 说说不同缓存间的差别"></a>2. 说说不同缓存间的差别</h2><ol>
<li><strong>Service Worker</strong></li>
</ol>
<p>和Web Worker类似，是独立的线程，我们可以在这个线程中缓存文件，在主线程需要的时候读取这里的文件，Service Worker使我们可以自由选择缓存哪些文件以及文件的匹配、读取规则，并且缓存是持续性的</p>
<ol start="2">
<li><strong>Memory Cache</strong></li>
</ol>
<p>即内存缓存，内存缓存不是持续性的，缓存会随着进程释放而释放</p>
<ol start="3">
<li><strong>Disk Cache</strong></li>
</ol>
<p>即硬盘缓存，相较于内存缓存，硬盘缓存的持续性和容量更优，它会根据HTTP header的字段判断哪些资源需要缓存</p>
<ol start="4">
<li><strong>Push Cache</strong></li>
</ol>
<p>即推送缓存，是HTTP&#x2F;2的内容，目前应用较少</p>
<h2 id="3-介绍一下浏览器缓存策略"><a href="#3-介绍一下浏览器缓存策略" class="headerlink" title="3. 介绍一下浏览器缓存策略"></a>3. 介绍一下浏览器缓存策略</h2><h3 id="强缓存-不要向服务器询问的缓存"><a href="#强缓存-不要向服务器询问的缓存" class="headerlink" title="强缓存(不要向服务器询问的缓存)"></a>强缓存(不要向服务器询问的缓存)</h3><ul>
<li><p><strong>设置Expires</strong></p>
<ul>
<li>即过期时间，例如「Expires: Thu, 26 Dec 2019 10:30:42 GMT」表示缓存会在这个时间后失效，这个过期日期是绝对日期，如果修改了本地日期，或者本地日期与服务器日期不一致，那么将导致缓存过期时间错误。</li>
</ul>
</li>
<li><p><strong>设置Cache-Control</strong></p>
<ul>
<li>HTTP&#x2F;1.1新增字段，Cache-Control可以通过max-age字段来设置过期时间，例如「Cache-Control:max-age&#x3D;3600」除此之外Cache-Control还能设置private&#x2F;no-cache等多种字段</li>
</ul>
</li>
</ul>
<h3 id="协商缓存-需要向服务器询问缓存是否已经过期"><a href="#协商缓存-需要向服务器询问缓存是否已经过期" class="headerlink" title="协商缓存(需要向服务器询问缓存是否已经过期)"></a>协商缓存(需要向服务器询问缓存是否已经过期)</h3><ul>
<li><p><strong>Last-Modified</strong></p>
<ul>
<li>即最后修改时间，浏览器第一次请求资源时，服务器会在响应头上加上Last-Modified ，当浏览器再次请求该资源时，浏览器会在请求头中带上If-Modified-Since 字段，字段的值就是之前服务器返回的最后修改时间，服务器对比这两个时间1</li>
</ul>
</li>
<li><p><strong>ETag</strong></p>
<ul>
<li>HTTP&#x2F;1.1新增字段，表示文件唯一标识，只要文件内容改动，ETag就会重新计算。缓存流程和 Last-Modified 一样：服务器发送 ETag 字段 -&gt; 浏览器再次请求时发送 If-None-Match -&gt; 如果ETag值不匹配，说明文件已经改变，返回新资源并更新ETag，若匹配则返回304</li>
</ul>
</li>
</ul>
<h3 id="两者对比"><a href="#两者对比" class="headerlink" title="两者对比"></a>两者对比</h3><ul>
<li><p>ETag 比 Last-Modified 更准确：如果我们打开文件但并没有修改，Last-Modified 也会改变，并且 Last-Modified 的单位时间为一秒，如果一秒内修改完了文件，那么还是会命中缓存</p>
</li>
<li><p>如果什么缓存策略都没有设置，那么浏览器会取响应头中的 Date 减去 Last-Modified 值的 10% 作为缓存时间</p>
</li>
</ul>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/1714a298b93c3208~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903473268391943">浏览器缓存机制剖析</a></p>
</blockquote>
<h1 id="网络相关"><a href="#网络相关" class="headerlink" title="网络相关"></a>网络相关</h1><h2 id="1-讲讲网络OSI七层模型，TCP-x2F-IP和HTTP分别位于哪一层"><a href="#1-讲讲网络OSI七层模型，TCP-x2F-IP和HTTP分别位于哪一层" class="headerlink" title="1. 讲讲网络OSI七层模型，TCP&#x2F;IP和HTTP分别位于哪一层"></a>1. 讲讲网络OSI七层模型，TCP&#x2F;IP和HTTP分别位于哪一层</h2><p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/1/28/16fec363208256b8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<table>
<thead>
<tr>
<th>模型</th>
<th>概述</th>
<th>单位</th>
</tr>
</thead>
<tbody><tr>
<td>物理层</td>
<td>网络连接介质，如网线、光缆，数据在其中以比特为单位传输</td>
<td>bit</td>
</tr>
<tr>
<td>数据链路层</td>
<td>数据链路层将比特封装成数据帧并传递</td>
<td>帧</td>
</tr>
<tr>
<td>网络层</td>
<td>定义IP地址，定义路由功能，建立主机到主机的通信</td>
<td>数据包</td>
</tr>
<tr>
<td>传输层</td>
<td>负责将数据进行可靠或者不可靠传递，建立端口到端口的通信</td>
<td>数据段</td>
</tr>
<tr>
<td>会话层</td>
<td>控制应用程序之间会话能力，区分不同的进程</td>
<td></td>
</tr>
<tr>
<td>表示层</td>
<td>数据格式标识，基本压缩加密功能</td>
<td></td>
</tr>
<tr>
<td>应用层</td>
<td>各种应用软件</td>
<td></td>
</tr>
</tbody></table>
<h2 id="2-常见HTTP状态码有哪些"><a href="#2-常见HTTP状态码有哪些" class="headerlink" title="2. 常见HTTP状态码有哪些"></a>2. 常见HTTP状态码有哪些</h2><ul>
<li><p><strong>2xx 开头（请求成功）</strong></p>
<ul>
<li><code>200 OK</code>：客户端发送给服务器的请求被正常处理并返回</li>
</ul>
</li>
<li><p><strong>3xx 开头（重定向）</strong></p>
<ul>
<li><code>301 Moved Permanently</code>：永久重定向，请求的网页已永久移动到新位置。 服务器返回此响应时，会自动将请求者转到新位置</li>
<li><code>302 Moved Permanently</code>：临时重定向，请求的网页已临时移动到新位置。服务器目前从不同位置的网页响应请求，但请求者应继续使用原有位置来进行以后的请求</li>
<li><code>304 Not Modified</code>：未修改，自从上次请求后，请求的网页未修改过。服务器返回此响应时，不会返回网页内容</li>
</ul>
</li>
<li><p><strong>4xx 开头（客户端错误）</strong></p>
<ul>
<li><code>400 Bad Request</code>：错误请求，服务器不理解请求的语法，常见于客户端传参错误</li>
<li><code>401 Unauthorized</code>：未授权，表示发送的请求需要有通过 HTTP 认证的认证信息，常见于客户端未登录</li>
<li><code>403 Forbidden</code>：禁止，服务器拒绝请求，常见于客户端权限不足</li>
<li><code>404 Not Found</code>：未找到，服务器找不到对应资源</li>
</ul>
</li>
<li><p><strong>5xx 开头（服务端错误）</strong></p>
<ul>
<li><p><code>500 Inter Server Error</code>：服务器内部错误，服务器遇到错误，无法完成请求</p>
</li>
<li><p><code>501 Not Implemented</code>：尚未实施，服务器不具备完成请求的功能</p>
</li>
<li><p><code>502 Bad Gateway</code>：作为网关或者代理工作的服务器尝试执行请求时，从上游服务器接收到无效的响应。</p>
</li>
<li><p><code>503 service unavailable</code>：服务不可用，服务器目前无法使用（处于超载或停机维护状态）。通常是暂时状态。</p>
</li>
</ul>
</li>
</ul>
<h2 id="3-GET请求和POST请求有何区别"><a href="#3-GET请求和POST请求有何区别" class="headerlink" title="3. GET请求和POST请求有何区别"></a>3. GET请求和POST请求有何区别</h2><h3 id="标准答案："><a href="#标准答案：" class="headerlink" title="标准答案："></a>标准答案：</h3><ul>
<li>GET请求参数放在URL上，POST请求参数放在请求体里</li>
<li>GET请求参数长度有限制，POST请求参数长度可以非常大</li>
<li>POST请求相较于GET请求安全一点点，因为GET请求的参数在URL上，且有历史记录</li>
<li>GET请求能缓存，POST不能</li>
</ul>
<h3 id="更进一步："><a href="#更进一步：" class="headerlink" title="更进一步："></a>更进一步：</h3><p>其实HTTP协议并没有要求GET&#x2F;POST请求参数必须放在URL上或请求体里，也没有规定GET请求的长度，目前对URL的长度限制，是各家浏览器设置的限制。GET和POST的根本区别在于：GET请求是幂等性的，而POST请求不是</p>
<h3 id="幂等性，指的是对某一资源进行一次或多次请求都具有相同的副作用。例如搜索就是一个幂等的操作，而删除、新增则不是一个幂等操作。"><a href="#幂等性，指的是对某一资源进行一次或多次请求都具有相同的副作用。例如搜索就是一个幂等的操作，而删除、新增则不是一个幂等操作。" class="headerlink" title="幂等性，指的是对某一资源进行一次或多次请求都具有相同的副作用。例如搜索就是一个幂等的操作，而删除、新增则不是一个幂等操作。"></a>幂等性，指的是对某一资源进行一次或多次请求都具有相同的副作用。例如搜索就是一个幂等的操作，而删除、新增则不是一个幂等操作。</h3><p>由于GET请求是幂等的，在网络不好的环境中，GET请求可能会重复尝试，造成重复操作数据的风险，因此，GET请求用于无副作用的操作(如搜索)，新增&#x2F;删除等操作适合用POST</p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903489127219214">HTTP｜GET 和 POST 区别？网上多数答案都是错的</a></p>
</blockquote>
<h2 id="4-HTTP的请求报文由哪几部分组成"><a href="#4-HTTP的请求报文由哪几部分组成" class="headerlink" title="4. HTTP的请求报文由哪几部分组成"></a>4. HTTP的请求报文由哪几部分组成</h2><p>一个HTTP请求报文由请求行（request line）、请求头（header）、空行和请求数据4个部分组成</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/1/16ffe7606c8db5e7~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>响应报文和请求报文结构类似，不再赘述</p>
<h2 id="5-HTTP常见请求-x2F-响应头及其含义"><a href="#5-HTTP常见请求-x2F-响应头及其含义" class="headerlink" title="5. HTTP常见请求&#x2F;响应头及其含义"></a>5. HTTP常见请求&#x2F;响应头及其含义</h2><h3 id="通用头（请求头和响应头都有的首部）"><a href="#通用头（请求头和响应头都有的首部）" class="headerlink" title="通用头（请求头和响应头都有的首部）"></a>通用头（请求头和响应头都有的首部）</h3><table>
<thead>
<tr>
<th>字段</th>
<th>作用</th>
<th>值</th>
</tr>
</thead>
<tbody><tr>
<td>Cache-Control</td>
<td>控制缓存</td>
<td>public：表示响应可以被任何对象缓存(包括客户端&#x2F;代理服务器) private(默认值)：响应只能被单个客户缓存,不能被代理服务器缓存 no-cache：缓存要经过服务器验证，在浏览器使用缓存前，会对比ETag，若没变则返回304，使用缓存 no-store：禁止任何缓存</td>
</tr>
<tr>
<td>Connection</td>
<td>是否需要持久连接(HTTP 1.1默认持久连接)</td>
<td>keep-alive &#x2F; close</td>
</tr>
<tr>
<td>Transfer-Encoding</td>
<td>报文主体的传输编码格式</td>
<td>chunked(分块) &#x2F; identity(未压缩和修改) &#x2F; gzip(LZ77压缩) &#x2F; compress(LZW压缩,弃用) &#x2F; deflate(zlib结构压缩)</td>
</tr>
</tbody></table>
<h3 id="请求头"><a href="#请求头" class="headerlink" title="请求头"></a>请求头</h3><table>
<thead>
<tr>
<th>字段</th>
<th>作用</th>
<th>语法</th>
</tr>
</thead>
<tbody><tr>
<td>Accept</td>
<td>告知（服务器）客户端可以处理的内容类型</td>
<td>text&#x2F;html、image&#x2F;<em>、</em>&#x2F;*</td>
</tr>
<tr>
<td>If-Modified-Since</td>
<td>将<code>Last-Modified</code>的值发送给服务器，询问资源是否已经过期(被修改)，过期则返回新资源，否则返回304</td>
<td>示例：If-Modified-Since: Wed, 21 Oct 2015 07:28:00 GMT</td>
</tr>
<tr>
<td>If-Unmodified-Since</td>
<td>将<code>Last-Modified</code>的值发送给服务器，询问文件是否被修改，若没有则返回200，否则返回412预处理错误，可用于断点续传。通俗点说<code>If-Unmodified-Since</code>是文件没有修改时下载，<code>If-Modified-Since</code>是文件修改时下载</td>
<td>示例：If-Unmodified-Since: Wed, 21 Oct 2015 07:28:00 GMT</td>
</tr>
<tr>
<td>If-None-Match</td>
<td>将<code>ETag</code>的值发送给服务器，询问资源是否已经过期(被修改)，过期则返回新资源，否则返回304</td>
<td>示例：If-None-Match: “bfc13a6472992d82d”</td>
</tr>
<tr>
<td>If-Match</td>
<td>将<code>ETag</code>的值发送给服务器，询问文件是否被修改，若没有则返回200，否则返回412预处理错误，可用于断点续传</td>
<td>示例：If-Match: “bfc129c88ca92d82d”</td>
</tr>
<tr>
<td>Range</td>
<td>告知服务器返回文件的哪一部分, 用于断点续传</td>
<td>示例：Range: bytes&#x3D;200-1000, 2000-6576, 19000-</td>
</tr>
<tr>
<td>Host</td>
<td>指明了服务器的域名（对于虚拟主机来说），以及（可选的）服务器监听的TCP端口号</td>
<td>示例：Host:<a target="_blank" rel="noopener" href="http://www.baidu.com/">www.baidu.com</a></td>
</tr>
<tr>
<td>User-Agent</td>
<td>告诉HTTP服务器， 客户端使用的操作系统和浏览器的名称和版本</td>
<td>User-Agent: Mozilla&#x2F;<version> (<system-information>) <platform> (<platform-details>) <extensions></td>
</tr>
</tbody></table>
<h3 id="响应头"><a href="#响应头" class="headerlink" title="响应头"></a>响应头</h3><table>
<thead>
<tr>
<th>字段</th>
<th>作用</th>
<th>语法</th>
</tr>
</thead>
<tbody><tr>
<td>Location</td>
<td>需要将页面重新定向至的地址。一般在响应码为3xx的响应中才会有意义</td>
<td>Location: <url></td>
</tr>
<tr>
<td>ETag</td>
<td>资源的特定版本的标识符，如果内容没有改变，Web服务器不需要发送完整的响应</td>
<td>ETag: “<etag_value>“</td>
</tr>
<tr>
<td>Server</td>
<td>处理请求的源头服务器所用到的软件相关信息</td>
<td>Server: <product></td>
</tr>
</tbody></table>
<h3 id="实体头（针对请求报文和响应报文的实体部分使用首部）"><a href="#实体头（针对请求报文和响应报文的实体部分使用首部）" class="headerlink" title="实体头（针对请求报文和响应报文的实体部分使用首部）"></a>实体头（针对请求报文和响应报文的实体部分使用首部）</h3><table>
<thead>
<tr>
<th>字段</th>
<th>作用</th>
<th>语法</th>
</tr>
</thead>
<tbody><tr>
<td>Allow</td>
<td>资源可支持http请求的方法</td>
<td>Allow: <http-methods>，示例：Allow: GET, POST, HEAD</td>
</tr>
<tr>
<td>Last-Modified</td>
<td>资源最后的修改时间，用作一个验证器来判断接收到的或者存储的资源是否彼此一致，精度不如ETag</td>
<td>示例：Last-Modified: Wed, 21 Oct 2020 07:28:00 GMT</td>
</tr>
<tr>
<td>Expires</td>
<td>响应过期时间</td>
<td>Expires: <http-date>，示例：Expires: Wed, 21 Oct 2020 07:28:00 GMT</td>
</tr>
</tbody></table>
<p>HTTP首部当然不止这么几个，但为了避免写太多大家记不住(主要是别的我也没去看)，这里只介绍了一些常用的，详细的可以看<a href="https://link.juejin.cn/?target=https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers">MDN的文档</a></p>
<h2 id="6-HTTP-x2F-1-0和HTTP-x2F-1-1有什么区别"><a href="#6-HTTP-x2F-1-0和HTTP-x2F-1-1有什么区别" class="headerlink" title="6. HTTP&#x2F;1.0和HTTP&#x2F;1.1有什么区别"></a>6. HTTP&#x2F;1.0和HTTP&#x2F;1.1有什么区别</h2><ul>
<li><strong>长连接</strong>： HTTP&#x2F;1.1支持长连接和请求的流水线，在一个TCP连接上可以传送多个HTTP请求，避免了因为多次建立TCP连接的时间消耗和延时</li>
<li><strong>缓存处理</strong>： HTTP&#x2F;1.1引入<code>Entity tag, If-Unmodified-Since, If-Match, If-None-Match</code>等新的请求头来控制缓存，详见浏览器缓存小节</li>
<li><strong>带宽优化及网络连接的使用</strong>： HTTP1.1则在请求头引入了range头域，支持断点续传功能</li>
<li><strong>Host头处理</strong>： 在HTTP&#x2F;1.0中认为每台服务器都有唯一的IP地址，但随着虚拟主机技术的发展，多个主机共享一个IP地址愈发普遍，HTTP1.1的请求消息和响应消息都应支持Host头域，且请求消息中如果没有Host头域会400错误</li>
</ul>
<h2 id="7-介绍一下HTTP-x2F-2-0新特性"><a href="#7-介绍一下HTTP-x2F-2-0新特性" class="headerlink" title="7. 介绍一下HTTP&#x2F;2.0新特性"></a>7. 介绍一下HTTP&#x2F;2.0新特性</h2><ul>
<li><p>多路复用： 即多个请求都通过一个TCP连接并发地完成</p>
</li>
<li><p>服务端推送： 服务端能够主动把资源推送给客户端</p>
</li>
<li><p>新的二进制格式： HTTP&#x2F;2采用二进制格式传输数据，相比于HTTP&#x2F;1.1的文本格式，二进制格式具有更好的解析性和拓展性</p>
</li>
<li><p>header压缩： HTTP&#x2F;2压缩消息头，减少了传输数据的大小</p>
</li>
</ul>
<h2 id="8-说说HTTP-x2F-2-0多路复用基本原理以及解决的问题"><a href="#8-说说HTTP-x2F-2-0多路复用基本原理以及解决的问题" class="headerlink" title="8. 说说HTTP&#x2F;2.0多路复用基本原理以及解决的问题"></a>8. 说说HTTP&#x2F;2.0多路复用基本原理以及解决的问题</h2><h3 id="HTTP-x2F-2解决的问题，就是HTTP-x2F-1-1存在的问题："><a href="#HTTP-x2F-2解决的问题，就是HTTP-x2F-1-1存在的问题：" class="headerlink" title="HTTP&#x2F;2解决的问题，就是HTTP&#x2F;1.1存在的问题："></a>HTTP&#x2F;2解决的问题，就是HTTP&#x2F;1.1存在的问题：</h3><ul>
<li><p>TCP慢启动： TCP连接建立后，会经历一个先慢后快的发送过程，就像汽车启动一般，如果我们的网页文件(HTML&#x2F;JS&#x2F;CSS&#x2F;icon)都经过一次慢启动，对性能是不小的损耗。另外慢启动是TCP为了减少网络拥塞的一种策略，我们是没有办法改变的。</p>
</li>
<li><p>多条TCP连接竞争带宽： 如果同时建立多条TCP连接，当带宽不足时就会竞争带宽，影响关键资源的下载。</p>
</li>
<li><p>HTTP&#x2F;1.1队头阻塞： 尽管HTTP&#x2F;1.1长链接可以通过一个TCP连接传输多个请求，但同一时刻只能处理一个请求，当前请求未结束前，其他请求只能处于阻塞状态。</p>
</li>
</ul>
<p>为了解决以上几个问题，<strong>HTTP&#x2F;2一个域名只使用一个TCP⻓连接来传输数据，而且请求直接是并行的、非阻塞的，这就是多路复用</strong></p>
<p><strong>实现原理</strong>： HTTP&#x2F;2引入了一个二进制分帧层，客户端和服务端进行传输时，数据会先经过二进制分帧层处理，转化为一个个带有请求ID的帧，这些帧在传输完成后根据ID组合成对应的数据。</p>
<h2 id="9-说说HTTP-x2F-3-0"><a href="#9-说说HTTP-x2F-3-0" class="headerlink" title="9. 说说HTTP&#x2F;3.0"></a>9. 说说HTTP&#x2F;3.0</h2><p>尽管HTTP&#x2F;2解决了很多1.1的问题，但HTTP&#x2F;2仍然存在一些缺陷，这些缺陷并不是来自于HTTP&#x2F;2协议本身，而是来源于底层的TCP协议，我们知道TCP链接是可靠的连接，如果出现了丢包，那么整个连接都要等待重传，HTTP&#x2F;1.1可以同时使用6个TCP连接，一个阻塞另外五个还能工作，但HTTP&#x2F;2只有一个TCP连接，阻塞的问题便被放大了。</p>
<p>由于TCP协议已经被广泛使用，我们很难直接修改TCP协议，基于此，HTTP&#x2F;3选择了一个折衷的方法——UDP协议，HTTP&#x2F;2在UDP的基础上实现多路复用、0-RTT、TLS加密、流量控制、丢包重传等功能。</p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844904001528397837#heading-9">http发展史(http0.9、http1.0、http1.1、http2、http3)梳理笔记</a> (推荐阅读)</p>
</blockquote>
<h2 id="10-HTTP和HTTPS有何区别"><a href="#10-HTTP和HTTPS有何区别" class="headerlink" title="10. HTTP和HTTPS有何区别"></a>10. HTTP和HTTPS有何区别</h2><ul>
<li>HTTPS使用443端口，而HTTP使用80</li>
<li>HTTPS需要申请证书</li>
<li>HTTP是超文本传输协议，是明文传输；HTTPS是经过SSL加密的协议，传输更安全</li>
<li>HTTPS比HTTP慢，因为HTTPS除了TCP握手的三个包，还要加上SSL握手的九个包</li>
</ul>
<h2 id="11-HTTPS是如何进行加密的"><a href="#11-HTTPS是如何进行加密的" class="headerlink" title="11. HTTPS是如何进行加密的"></a>11. HTTPS是如何进行加密的</h2><p>我们通过分析几种加密方式，层层递进，理解HTTPS的加密方式以及为什么使用这种加密方式：</p>
<h3 id="对称加密"><a href="#对称加密" class="headerlink" title="对称加密"></a>对称加密</h3><p>客户端和服务器公用一个密匙用来对消息加解密，这种方式称为对称加密。客户端和服务器约定好一个加密的密匙。客户端在发消息前用该密匙对消息加密，发送给服务器后，服务器再用该密匙进行解密拿到消息。</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/170097ce30734773~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>这种方式一定程度上保证了数据的安全性，但密钥一旦泄露(密钥在传输过程中被截获)，传输内容就会暴露，因此我们要寻找一种安全传递密钥的方法。</p>
<h3 id="非对称加密"><a href="#非对称加密" class="headerlink" title="非对称加密"></a>非对称加密</h3><p>采用非对称加密时，客户端和服务端均拥有一个公钥和私钥，公钥加密的内容只有对应的私钥能解密。私钥自己留着，公钥发给对方。这样在发送消息前，先用对方的公钥对消息进行加密，收到后再用自己的私钥进行解密。这样攻击者只拿到传输过程中的公钥也无法破解传输的内容</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/1700980f4879f2b8~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>尽管非对称加密解决了由于密钥被获取而导致传输内容泄露的问题，但中间人仍然可以用篡改公钥的方式来获取或篡改传输内容，而且非对称加密的性能比对称加密的性能差了不少</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/17009369c26da64b~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h3 id="第三方认证"><a href="#第三方认证" class="headerlink" title="第三方认证"></a>第三方认证</h3><p>上面这种方法的弱点在于，客户端不知道公钥是由服务端返回，还是中间人返回的，因此我们再引入一个第三方认证的环节：即第三方使用私钥加密我们<code>自己的公钥</code>，浏览器已经内置一些权威第三方认证机构的公钥，浏览器会使用<code>第三方的公钥</code>来解开<code>第三方私钥加密过的我们自己的公钥</code>，从而获取公钥，如果能成功解密，就说明获取到的<code>自己的公钥</code>是正确的</p>
<p>但第三方认证也未能完全解决问题，第三方认证是面向所有人的，中间人也能申请证书，如果中间人使用自己的证书掉包原证书，客户端还是无法确认公钥的真伪</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/3/1700962e1949c343~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h3 id="数字签名"><a href="#数字签名" class="headerlink" title="数字签名"></a>数字签名</h3><p>为了让客户端能够验证公钥的来源，我们给公钥加上一个数字签名，这个数字签名是由企业、网站等各种信息和公钥经过单向hash而来，一旦构成数字签名的信息发生变化，hash值就会改变，这就构成了公钥来源的唯一标识。</p>
<p>具体来说，服务端本地生成一对密钥，然后拿着公钥以及企业、网站等各种信息到CA(第三方认证中心)去申请数字证书，CA会通过一种单向hash算法(比如MD5)，生成一串摘要，这串摘要就是这堆信息的唯一标识，然后CA还会使用自己的私钥对摘要进行加密，连同我们自己服务器的公钥一同发送给我我们。</p>
<p>浏览器拿到数字签名后，会使用浏览器本地内置的CA公钥解开数字证书并验证，从而拿到正确的公钥。由于非对称加密性能低下，拿到公钥以后，客户端会随机生成一个对称密钥，使用这个公钥加密并发送给服务端，服务端用自己的私钥解开对称密钥，此后的加密连接就通过这个对称密钥进行对称加密。</p>
<p>综上所述，HTTPS在验证阶段使用非对称加密+第三方认证+数字签名获取正确的公钥，获取到正确的公钥后以对称加密的方式通信</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714e043d3a1add2~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<blockquote>
<p>参考资料：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844903608421449742#heading-5">看图学HTTPS</a></p>
</blockquote>
<h1 id="前端安全"><a href="#前端安全" class="headerlink" title="前端安全"></a>前端安全</h1><h2 id="什么是CSRF攻击"><a href="#什么是CSRF攻击" class="headerlink" title="什么是CSRF攻击"></a>什么是CSRF攻击</h2><blockquote>
<p>CSRF即Cross-site request forgery(跨站请求伪造)，是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。</p>
</blockquote>
<p>假如黑客在自己的站点上放置了其他网站的外链，例如<code>www.weibo.com/api</code>，默认情况下，浏览器会带着<code>weibo.com</code>的cookie访问这个网址，如果用户已登录过该网站且网站没有对CSRF攻击进行防御，那么服务器就会认为是用户本人在调用此接口并执行相关操作，致使账号被劫持。</p>
<h2 id="如何防御CSRF攻击"><a href="#如何防御CSRF攻击" class="headerlink" title="如何防御CSRF攻击"></a>如何防御CSRF攻击</h2><ul>
<li>验证<code>Token</code>：浏览器请求服务器时，服务器返回一个token，每个请求都需要同时带上token和cookie才会被认为是合法请求</li>
<li>验证<code>Referer</code>：通过验证请求头的Referer来验证来源站点，但请求头很容易伪造</li>
<li>设置<code>SameSite</code>：设置cookie的SameSite，可以让cookie不随跨域请求发出，但浏览器兼容不一</li>
</ul>
<h2 id="什么是XSS攻击"><a href="#什么是XSS攻击" class="headerlink" title="什么是XSS攻击"></a>什么是XSS攻击</h2><blockquote>
<p>XSS即Cross Site Scripting（跨站脚本），指的是通过利用网页开发时留下的漏洞，注入恶意指令代码到网页，使用户加载并执行攻击者恶意制造的网页程序。常见的例如在评论区植入JS代码，用户进入评论页时代码被执行，造成页面被植入广告、账号信息被窃取</p>
</blockquote>
<h2 id="XSS攻击有哪些类型"><a href="#XSS攻击有哪些类型" class="headerlink" title="XSS攻击有哪些类型"></a>XSS攻击有哪些类型</h2><ul>
<li><strong>存储型</strong>：即攻击被存储在服务端，常见的是在评论区插入攻击脚本，如果脚本被储存到服务端，那么所有看见对应评论的用户都会受到攻击。</li>
<li><strong>反射型</strong>：攻击者将脚本混在URL里，服务端接收到URL将恶意代码当做参数取出并拼接在HTML里返回，浏览器解析此HTML后即执行恶意代码</li>
<li><strong>DOM型</strong>：将攻击脚本写在URL中，诱导用户点击该URL，如果URL被解析，那么攻击脚本就会被运行。和前两者的差别主要在于DOM型攻击不经过服务端</li>
</ul>
<h2 id="如何防御XSS攻击"><a href="#如何防御XSS攻击" class="headerlink" title="如何防御XSS攻击"></a>如何防御XSS攻击</h2><ul>
<li><strong>输入检查</strong>：对输入内容中的<code>&lt;script&gt;&lt;iframe&gt;</code>等标签进行转义或者过滤</li>
<li><strong>设置httpOnly</strong>：很多XSS攻击目标都是窃取用户cookie伪造身份认证，设置此属性可防止JS获取cookie</li>
<li><strong>开启CSP</strong>：即开启白名单，可阻止白名单以外的资源加载和运行</li>
</ul>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714ff9939df9d71~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h1 id="排序算法"><a href="#排序算法" class="headerlink" title="排序算法"></a>排序算法</h1><h2 id="1-手写冒泡排序"><a href="#1-手写冒泡排序" class="headerlink" title="1. 手写冒泡排序"></a>1. 手写冒泡排序</h2><blockquote>
<p>冒泡排序应该是很多人第一个接触的排序，比较简单，不展开讲解了</p>
</blockquote>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">bubbleSort</span>(<span class="hljs-params">arr</span>)&#123;
  <span class="hljs-keyword">for</span>(<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &lt; arr.<span class="hljs-property">length</span>; i++) &#123;
    <span class="hljs-keyword">for</span>(<span class="hljs-keyword">let</span> j = <span class="hljs-number">0</span>; j &lt; arr.<span class="hljs-property">length</span> - i - <span class="hljs-number">1</span>; j++) &#123;
      <span class="hljs-keyword">if</span>(arr[j] &gt; arr[j+<span class="hljs-number">1</span>]) &#123;
        <span class="hljs-keyword">let</span> temp = arr[j]
        arr[j] = arr[j+<span class="hljs-number">1</span>]
        arr[j+<span class="hljs-number">1</span>] = temp
      &#125;
    &#125;
  &#125;
  <span class="hljs-keyword">return</span> arr
&#125;</code></pre></div>

<h2 id="2-如何优化一个冒泡排序"><a href="#2-如何优化一个冒泡排序" class="headerlink" title="2. 如何优化一个冒泡排序"></a>2. 如何优化一个冒泡排序</h2><blockquote>
<p>冒泡排序总会执行(N-1)+(N-2)+(N-3)+..+2+1趟，但如果运行到当中某一趟时排序已经完成，或者输入的是一个有序数组，那么后边的比较就都是多余的，为了避免这种情况，我们增加一个flag，判断排序是否在中途就已经完成（也就是判断有无发生元素交换）</p>
</blockquote>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">bubbleSort</span>(<span class="hljs-params">arr</span>)&#123;
  <span class="hljs-keyword">for</span>(<span class="hljs-keyword">let</span> i = <span class="hljs-number">0</span>; i &lt; arr.<span class="hljs-property">length</span>; i++) &#123;
  <span class="hljs-keyword">let</span> flag = <span class="hljs-literal">true</span>
    <span class="hljs-keyword">for</span>(<span class="hljs-keyword">let</span> j = <span class="hljs-number">0</span>; j &lt; arr.<span class="hljs-property">length</span> - i - <span class="hljs-number">1</span>; j++) &#123;
      <span class="hljs-keyword">if</span>(arr[j] &gt; arr[j+<span class="hljs-number">1</span>]) &#123;
        flag = <span class="hljs-literal">false</span>
        <span class="hljs-keyword">let</span> temp = arr[j]
        arr[j] = arr[j+<span class="hljs-number">1</span>]
        arr[j+<span class="hljs-number">1</span>] = temp
      &#125;
    &#125;
    <span class="hljs-comment">// 这个flag的含义是：如果`某次循环`中没有交换过元素，那么意味着排序已经完成</span>
    <span class="hljs-keyword">if</span>(flag)<span class="hljs-keyword">break</span>;
  &#125;
  <span class="hljs-keyword">return</span> arr
&#125;</code></pre></div>

<h2 id="3-手写快速排序"><a href="#3-手写快速排序" class="headerlink" title="3. 手写快速排序"></a>3. 手写快速排序</h2><h3 id="快排基本步骤："><a href="#快排基本步骤：" class="headerlink" title="快排基本步骤："></a>快排基本步骤：</h3><ol>
<li><p>选取基准元素</p>
</li>
<li><p>比基准元素小的元素放到左边，大的放右边</p>
</li>
<li><p>在左右子数组中重复步骤一二，直到数组只剩下一个元素</p>
</li>
<li><p>向上逐级合并数组</p>
</li>
</ol>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">quickSort</span>(<span class="hljs-params">arr</span>) &#123;
    <span class="hljs-keyword">if</span>(arr.<span class="hljs-property">length</span> &lt;= <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> arr          <span class="hljs-comment">//递归终止条件</span>
    <span class="hljs-keyword">const</span> pivot = arr.<span class="hljs-property">length</span> / <span class="hljs-number">2</span> | <span class="hljs-number">0</span>        <span class="hljs-comment">//基准点</span>
    <span class="hljs-keyword">const</span> pivotValue = arr.<span class="hljs-title function_">splice</span>(pivot, <span class="hljs-number">1</span>)[<span class="hljs-number">0</span>]
    <span class="hljs-keyword">const</span> leftArr = []
    <span class="hljs-keyword">const</span> rightArr = []
    arr.<span class="hljs-title function_">forEach</span>(<span class="hljs-function"><span class="hljs-params">val</span> =&gt;</span> &#123;
        val &gt; pivotValue ? rightArr.<span class="hljs-title function_">push</span>(val) : leftArr.<span class="hljs-title function_">push</span>(val)
    &#125;)
    <span class="hljs-keyword">return</span> [ ...<span class="hljs-title function_">quickSort</span>(leftArr), pivotValue, ...<span class="hljs-title function_">quickSort</span>(rightArr)]
&#125;</code></pre></div>

<h2 id="4-如何优化一个快速排序"><a href="#4-如何优化一个快速排序" class="headerlink" title="4. 如何优化一个快速排序"></a>4. 如何优化一个快速排序</h2><h3 id="1-原地排序"><a href="#1-原地排序" class="headerlink" title="1. 原地排序"></a>1. 原地排序</h3><p>上边这个快排只是让读者找找感觉，我们不能这样写快排，如果每次都开两个数组，会消耗很多内存空间，数据量大时可能造成内存溢出，我们要避免开新的内存空间，即原地完成排序</p>
<p>我们可以用元素交换来取代开新数组，在每一次分区的时候直接在原数组上交换元素，将小于基准数的元素挪到数组开头，以[<code>5,1,4,2,3]</code>为例：</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17148debd6e97be5~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>我们定义一个pos指针, 标识等待置换的元素的位置, 然后逐一遍历数组元素, 遇到比基准数小的就和arr[pos]交换位置, 然后pos++<br>代码实现：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">quickSort</span>(<span class="hljs-params">arr, left, right</span>) &#123;          <span class="hljs-comment">//这个left和right代表分区后“新数组”的区间下标，因为这里没有新开数组，所以需要left/right来确认新数组的位置</span>
    <span class="hljs-keyword">if</span> (left &lt; right) &#123;
        <span class="hljs-keyword">let</span> pos = left - <span class="hljs-number">1</span>                      <span class="hljs-comment">//pos即“被置换的位置”，第一趟为-1</span>
        <span class="hljs-keyword">for</span>(<span class="hljs-keyword">let</span> i = left; i &lt;= right; i++) &#123;    <span class="hljs-comment">//循环遍历数组，置换元素</span>
            <span class="hljs-keyword">let</span> pivot = arr[right]              <span class="hljs-comment">//选取数组最后一位作为基准数，</span>
            <span class="hljs-keyword">if</span>(arr[i] &lt;= pivot) &#123;               <span class="hljs-comment">//若小于等于基准数，pos++，并置换元素, 这里使用小于等于而不是小于, 其实是为了避免因为重复数据而进入死循环</span>
                pos++
                <span class="hljs-keyword">let</span> temp = arr[pos]
                arr[pos] = arr[i]
                arr[i] = temp
            &#125;
        &#125;
        <span class="hljs-comment">//一趟排序完成后，pos位置即基准数的位置，以pos的位置分割数组</span>
        <span class="hljs-title function_">quickSort</span>(arr, left, pos - <span class="hljs-number">1</span>)        
        <span class="hljs-title function_">quickSort</span>(arr, pos + <span class="hljs-number">1</span>, right)
    &#125;
    <span class="hljs-keyword">return</span> arr      <span class="hljs-comment">//数组只包含1或0个元素时(即left&gt;=right)，递归终止</span>
&#125;

<span class="hljs-comment">//使用</span>
<span class="hljs-keyword">var</span> arr = [<span class="hljs-number">5</span>,<span class="hljs-number">1</span>,<span class="hljs-number">4</span>,<span class="hljs-number">2</span>,<span class="hljs-number">3</span>]
<span class="hljs-keyword">var</span> start = <span class="hljs-number">0</span>;
<span class="hljs-keyword">var</span> end = arr.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>;
<span class="hljs-title function_">quickSort</span>(arr, start, end)</code></pre></div>

<p>这个交换的过程还是需要一些时间理解消化的，详细分析可以看这篇：<a href="https://link.juejin.cn/?target=https://segmentfault.com/a/1190000017814119">js算法-快速排序(Quicksort)</a></p>
<h3 id="2-三路快排"><a href="#2-三路快排" class="headerlink" title="2. 三路快排"></a>2. 三路快排</h3><p>上边这个快排还谈不上优化，应当说是快排的纠正写法，其实有两个问题我们还能优化一下：</p>
<ol>
<li><strong>有序数组的情况</strong>：如果输入的数组是有序的，而取基准点时也顺序取，就可能导致基准点一侧的子数组一直为空, 使时间复杂度退化到O(n2)</li>
<li><strong>大量重复数据的情况</strong>：例如输入的数据是<code>[1,2,2,2,2,3]</code>, 无论基准点取1、2还是3, 都会导致基准点两侧数组大小不平衡, 影响快排效率</li>
</ol>
<p>对于第一个问题, 我们可以通过在取基准点的时候随机化来解决，对于第二个问题，我们可以使用<code>三路快排</code>的方式来优化，比方说对于上面的<code>[1,2,2,2,2,3]</code>，我们基准点取2，在分区的时候，将数组元素分为<code>小于2 | 等于2 | 大于2</code>三个区域，其中等于基准点的部分不再进入下一次排序, 这样就大大提高了快排效率</p>
<h2 id="5-手写归并排序"><a href="#5-手写归并排序" class="headerlink" title="5. 手写归并排序"></a>5. 手写归并排序</h2><blockquote>
<p>归并排序和快排的思路类似，都是递归分治，区别在于快排边分区边排序，而归并在分区完成后才会排序</p>
</blockquote>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/2/2/1700388b88d9102c~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">mergeSort</span>(<span class="hljs-params">arr</span>) &#123;
    <span class="hljs-keyword">if</span>(arr.<span class="hljs-property">length</span> &lt;= <span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> arr		<span class="hljs-comment">//数组元素被划分到剩1个时，递归终止</span>
    <span class="hljs-keyword">const</span> midIndex = arr.<span class="hljs-property">length</span>/<span class="hljs-number">2</span> | <span class="hljs-number">0</span>
    <span class="hljs-keyword">const</span> leftArr = arr.<span class="hljs-title function_">slice</span>(<span class="hljs-number">0</span>, midIndex)
    <span class="hljs-keyword">const</span> rightArr = arr.<span class="hljs-title function_">slice</span>(midIndex, arr.<span class="hljs-property">length</span>)
    <span class="hljs-keyword">return</span> <span class="hljs-title function_">merge</span>(<span class="hljs-title function_">mergeSort</span>(leftArr), <span class="hljs-title function_">mergeSort</span>(rightArr))	<span class="hljs-comment">//先划分，后合并</span>
&#125;

<span class="hljs-comment">//合并</span>
<span class="hljs-keyword">function</span> <span class="hljs-title function_">merge</span>(<span class="hljs-params">leftArr, rightArr</span>) &#123;
    <span class="hljs-keyword">const</span> result = []
    <span class="hljs-keyword">while</span>(leftArr.<span class="hljs-property">length</span> &amp;&amp; rightArr.<span class="hljs-property">length</span>) &#123;
    	leftArr[<span class="hljs-number">0</span>] &lt;= rightArr[<span class="hljs-number">0</span>] ? result.<span class="hljs-title function_">push</span>(leftArr.<span class="hljs-title function_">shift</span>()) : result.<span class="hljs-title function_">push</span>(rightArr.<span class="hljs-title function_">shift</span>())
    &#125;
    <span class="hljs-keyword">while</span>(leftArr.<span class="hljs-property">length</span>) result.<span class="hljs-title function_">push</span>(leftArr.<span class="hljs-title function_">shift</span>())
    <span class="hljs-keyword">while</span>(rightArr.<span class="hljs-property">length</span>) result.<span class="hljs-title function_">push</span>(rightArr.<span class="hljs-title function_">shift</span>())
    <span class="hljs-keyword">return</span> result
&#125;</code></pre></div>

<h2 id="6-手写堆排序"><a href="#6-手写堆排序" class="headerlink" title="6. 手写堆排序"></a>6. 手写堆排序</h2><blockquote>
<p>堆是一棵特殊的树, 只要满足这棵树是完全二叉树和堆中每一个节点的值都大于或小于其左右孩子节点这两个条件, 那么就是一个堆, 根据堆中每一个节点的值都大于或小于其左右孩子节点, 又分为大根堆和小根堆</p>
</blockquote>
<p><strong>堆排序的流程：</strong></p>
<ol>
<li><p>初始化大(小)根堆，此时根节点为最大(小)值，将根节点与最后一个节点(数组最后一个元素)交换</p>
</li>
<li><p>除开最后一个节点，重新调整大(小)根堆，使根节点为最大(小)值</p>
</li>
<li><p>重复步骤二，直到堆中元素剩一个，排序完成</p>
</li>
</ol>
<p>以<code>[1,5,4,2,3</code>]为例构筑大根堆：</p>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/17148e2325d08c76~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>代码实现：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">// 堆排序</span>
<span class="hljs-keyword">const</span> <span class="hljs-title function_">heapSort</span> = array =&gt; &#123;
        <span class="hljs-comment">// 我们用数组来储存这个大根堆,数组就是堆本身</span>
	<span class="hljs-comment">// 初始化大顶堆，从第一个非叶子结点开始</span>
	<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">floor</span>(array.<span class="hljs-property">length</span> / <span class="hljs-number">2</span> - <span class="hljs-number">1</span>); i &gt;= <span class="hljs-number">0</span>; i--) &#123;
		<span class="hljs-title function_">heapify</span>(array, i, array.<span class="hljs-property">length</span>);
	&#125;
	<span class="hljs-comment">// 排序，每一次 for 循环找出一个当前最大值，数组长度减一</span>
	<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> i = <span class="hljs-title class_">Math</span>.<span class="hljs-title function_">floor</span>(array.<span class="hljs-property">length</span> - <span class="hljs-number">1</span>); i &gt; <span class="hljs-number">0</span>; i--) &#123;
		<span class="hljs-comment">// 根节点与最后一个节点交换</span>
		<span class="hljs-title function_">swap</span>(array, <span class="hljs-number">0</span>, i);
		<span class="hljs-comment">// 从根节点开始调整，并且最后一个结点已经为当前最大值，不需要再参与比较，所以第三个参数为 i，即比较到最后一个结点前一个即可</span>
		<span class="hljs-title function_">heapify</span>(array, <span class="hljs-number">0</span>, i);
	&#125;
	<span class="hljs-keyword">return</span> array;
&#125;;

<span class="hljs-comment">// 交换两个节点</span>
<span class="hljs-keyword">const</span> <span class="hljs-title function_">swap</span> = (<span class="hljs-params">array, i, j</span>) =&gt; &#123;
	<span class="hljs-keyword">let</span> temp = array[i];
	array[i] = array[j];
	array[j] = temp;
&#125;;

<span class="hljs-comment">// 将 i 结点以下的堆整理为大顶堆，注意这一步实现的基础实际上是：</span>
<span class="hljs-comment">// 假设结点 i 以下的子堆已经是一个大顶堆，heapify 函数实现的</span>
<span class="hljs-comment">// 功能是实际上是：找到 结点 i 在包括结点 i 的堆中的正确位置。</span>
<span class="hljs-comment">// 后面将写一个 for 循环，从第一个非叶子结点开始，对每一个非叶子结点</span>
<span class="hljs-comment">// 都执行 heapify 操作，所以就满足了结点 i 以下的子堆已经是一大顶堆</span>
<span class="hljs-keyword">const</span> <span class="hljs-title function_">heapify</span> = (<span class="hljs-params">array, i, length</span>) =&gt; &#123;
	<span class="hljs-keyword">let</span> temp = array[i]; <span class="hljs-comment">// 当前父节点</span>
	<span class="hljs-comment">// j &lt; length 的目的是对结点 i 以下的结点全部做顺序调整</span>
	<span class="hljs-keyword">for</span> (<span class="hljs-keyword">let</span> j = <span class="hljs-number">2</span> * i + <span class="hljs-number">1</span>; j &lt; length; j = <span class="hljs-number">2</span> * j + <span class="hljs-number">1</span>) &#123;
		temp = array[i]; <span class="hljs-comment">// 将 array[i] 取出，整个过程相当于找到 array[i] 应处于的位置</span>
		<span class="hljs-keyword">if</span> (j + <span class="hljs-number">1</span> &lt; length &amp;&amp; array[j] &lt; array[j + <span class="hljs-number">1</span>]) &#123;
			j++; <span class="hljs-comment">// 找到两个孩子中较大的一个，再与父节点比较</span>
		&#125;
		<span class="hljs-keyword">if</span> (temp &lt; array[j]) &#123;
			<span class="hljs-title function_">swap</span>(array, i, j); <span class="hljs-comment">// 如果父节点小于子节点:交换；否则跳出</span>
			i = j; <span class="hljs-comment">// 交换后，temp 的下标变为 j</span>
		&#125; <span class="hljs-keyword">else</span> &#123;
			<span class="hljs-keyword">break</span>;
		&#125;
	&#125;
&#125;</code></pre></div>

<blockquote>
<p>参考资料: <a href="https://link.juejin.cn/?target=https://www.jianshu.com/p/90bf2dcd6a7b">JS实现堆排序</a></p>
</blockquote>
<h2 id="7-归并、快排、堆排有何区别"><a href="#7-归并、快排、堆排有何区别" class="headerlink" title="7. 归并、快排、堆排有何区别"></a>7. 归并、快排、堆排有何区别</h2><table>
<thead>
<tr>
<th>排序</th>
<th>时间复杂度(最好情况)</th>
<th>时间复杂度(最坏情况)</th>
<th>空间复杂度</th>
<th>稳定性</th>
</tr>
</thead>
<tbody><tr>
<td>快速排序</td>
<td>O(nlogn)</td>
<td>O(n^2)</td>
<td>O(logn)~O(n)</td>
<td>不稳定</td>
</tr>
<tr>
<td>归并排序</td>
<td>O(nlogn)</td>
<td>O(nlogn)</td>
<td>O(n)</td>
<td>稳定</td>
</tr>
<tr>
<td>堆排序</td>
<td>O(nlogn)</td>
<td>O(nlogn)</td>
<td>O(1)</td>
<td>不稳定</td>
</tr>
</tbody></table>
<p>其实从表格中我们可以看到，就时间复杂度而言，快排并没有很大优势，然而为什么快排会成为最常用的排序手段，这是因为时间复杂度只能说明<code>随着数据量的增加，算法时间代价增长的趋势</code>，并不直接代表实际执行时间，实际运行时间还包括了很多常数参数的差别，此外在面对不同类型数据(比如有序数据、大量重复数据)时，表现也不同，综合来说，快排的时间效率是最高的<br>在实际运用中, 并不只使用一种排序手段, 例如V8的<code>Array.sort()</code>就采取了<strong>当 n&lt;&#x3D;10 时, 采用插入排序, 当 n&gt;10 时，采用三路快排</strong>的排序策略<br><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714ffee2595a85c~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h1 id="设计模式"><a href="#设计模式" class="headerlink" title="设计模式"></a>设计模式</h1><p>设计模式有许多种，这里挑出几个常用的：</p>
<table>
<thead>
<tr>
<th>设计模式</th>
<th>描述</th>
<th>例子</th>
</tr>
</thead>
<tbody><tr>
<td>单例模式</td>
<td>一个类只能构造出唯一实例</td>
<td>Redux&#x2F;Vuex的store</td>
</tr>
<tr>
<td>工厂模式</td>
<td>对创建对象逻辑的封装</td>
<td>jQuery的$(selector)</td>
</tr>
<tr>
<td>观察者模式</td>
<td>当一个对象被修改时，会自动通知它的依赖对象</td>
<td>Redux的subscribe、Vue的双向绑定</td>
</tr>
<tr>
<td>装饰器模式</td>
<td>对类的包装，动态地拓展类的功能</td>
<td>React高阶组件、ES7 装饰器</td>
</tr>
<tr>
<td>适配器模式</td>
<td>兼容新旧接口，对类的包装</td>
<td>封装旧API</td>
</tr>
<tr>
<td>代理模式</td>
<td>控制对象的访问</td>
<td>事件代理、ES6的Proxy</td>
</tr>
</tbody></table>
<h2 id="1-介绍一下单一职责原则和开放封闭原则"><a href="#1-介绍一下单一职责原则和开放封闭原则" class="headerlink" title="1. 介绍一下单一职责原则和开放封闭原则"></a>1. 介绍一下单一职责原则和开放封闭原则</h2><ol>
<li><p>单一职责原则：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。</p>
</li>
<li><p>开放封闭原则：核心的思想是软件实体（类、模块、函数等）是可扩展的、但不可修改的。也就是说,对扩展是开放的,而对修改是封闭的。</p>
</li>
</ol>
<h2 id="2-单例模式"><a href="#2-单例模式" class="headerlink" title="2. 单例模式"></a>2. 单例模式</h2><p>单例模式即一个类只能构造出唯一实例，单例模式的意义在于<strong>共享、唯一</strong>，<code>Redux/Vuex</code>中的<code>store</code>、<code>JQ</code>的<code>$</code>或者业务场景中的购物车、登录框都是单例模式的应用</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">class</span> <span class="hljs-title class_">SingletonLogin</span> &#123;
 <span class="hljs-title function_">constructor</span>(<span class="hljs-params">name,password</span>)&#123;
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = name
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">password</span> = password
 &#125;
 <span class="hljs-keyword">static</span> <span class="hljs-title function_">getInstance</span>(<span class="hljs-params">name,password</span>)&#123;
 <span class="hljs-comment">//判断对象是否已经被创建,若创建则返回旧对象</span>
 <span class="hljs-keyword">if</span>(!<span class="hljs-variable language_">this</span>.<span class="hljs-property">instance</span>)<span class="hljs-variable language_">this</span>.<span class="hljs-property">instance</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">SingletonLogin</span>(name,password)
 <span class="hljs-keyword">return</span> <span class="hljs-variable language_">this</span>.<span class="hljs-property">instance</span>
 &#125;
&#125;

<span class="hljs-keyword">let</span> obj1 = <span class="hljs-title class_">SingletonLogin</span>.<span class="hljs-title function_">getInstance</span>(<span class="hljs-string">&#x27;CXK&#x27;</span>,<span class="hljs-string">&#x27;123&#x27;</span>)
<span class="hljs-keyword">let</span> obj2 = <span class="hljs-title class_">SingletonLogin</span>.<span class="hljs-title function_">getInstance</span>(<span class="hljs-string">&#x27;CXK&#x27;</span>,<span class="hljs-string">&#x27;321&#x27;</span>)

<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj1===obj2)    <span class="hljs-comment">// true</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj1)           <span class="hljs-comment">// &#123;name:CXK,password:123&#125;</span>
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(obj2)           <span class="hljs-comment">// 输出的依然是&#123;name:CXK,password:123&#125;</span></code></pre></div>

<h2 id="3-工厂模式"><a href="#3-工厂模式" class="headerlink" title="3. 工厂模式"></a>3. 工厂模式</h2><p>工厂模式即对创建对象逻辑的封装，或者可以简单理解为对<code>new</code>的封装，这种封装就像创建对象的工厂，故名工厂模式。工厂模式常见于大型项目，比如JQ的$对象，我们创建选择器对象时之所以没有new selector就是因为$()已经是一个工厂方法，其他例子例如<code>React.createElement()</code>、<code>Vue.component()</code>都是工厂模式的实现。工厂模式有多种：<code>简单工厂模式</code>、<code>工厂方法模式</code>、<code>抽象工厂模式</code>，这里只以简单工厂模式为例：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">class</span> <span class="hljs-title class_">User</span> &#123;
 <span class="hljs-title function_">constructor</span>(<span class="hljs-params">name, auth</span>) &#123;
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">name</span> = name
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">auth</span> = auth
 &#125;
&#125;

<span class="hljs-keyword">class</span> <span class="hljs-title class_">UserFactory</span> &#123;
  <span class="hljs-keyword">static</span> <span class="hljs-title function_">createUser</span>(<span class="hljs-params">name, auth</span>) &#123;
    <span class="hljs-comment">//工厂内部封装了创建对象的逻辑:</span>
    <span class="hljs-comment">//权限为admin时,auth=1, 权限为user时, auth为2</span>
    <span class="hljs-comment">//使用者在外部创建对象时,不需要知道各个权限对应哪个字段, 不需要知道赋权的逻辑，只需要知道创建了一个管理员和用户</span>
    <span class="hljs-keyword">if</span>(auth === <span class="hljs-string">&#x27;admin&#x27;</span>)  <span class="hljs-keyword">new</span> <span class="hljs-title class_">User</span>(name, <span class="hljs-number">1</span>)
    <span class="hljs-keyword">if</span>(auth === <span class="hljs-string">&#x27;user&#x27;</span>)  <span class="hljs-keyword">new</span> <span class="hljs-title class_">User</span>(name, <span class="hljs-number">2</span>)
  &#125;
&#125;

<span class="hljs-keyword">const</span> admin = <span class="hljs-title class_">UserFactory</span>.<span class="hljs-title function_">createUser</span>(<span class="hljs-string">&#x27;cxk&#x27;</span>, <span class="hljs-string">&#x27;admin&#x27;</span>);
<span class="hljs-keyword">const</span> user = <span class="hljs-title class_">UserFactory</span>.<span class="hljs-title function_">createUser</span>(<span class="hljs-string">&#x27;cxk&#x27;</span>, <span class="hljs-string">&#x27;user&#x27;</span>);</code></pre></div>

<h2 id="4-观察者模式"><a href="#4-观察者模式" class="headerlink" title="4. 观察者模式"></a>4. 观察者模式</h2><p>观察者模式算是前端最常用的设计模式了，观察者模式概念很简单：观察者监听被观察者的变化，被观察者发生改变时，通知所有的观察者。观察者模式被广泛用于监听事件的实现，有关观察者模式的详细应用，可以看我另一篇讲解<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844904036013965325#heading-3">Redux实现的文章</a></p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-comment">//观察者</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">Observer</span> &#123;    
 <span class="hljs-title function_">constructor</span> (fn) &#123;      
 <span class="hljs-variable language_">this</span>.<span class="hljs-property">update</span> = fn    
 &#125;
&#125;
<span class="hljs-comment">//被观察者</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">Subject</span> &#123;    
 <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) &#123;        
     <span class="hljs-variable language_">this</span>.<span class="hljs-property">observers</span> = []          <span class="hljs-comment">//观察者队列    </span>
 &#125;    
 <span class="hljs-title function_">addObserver</span>(<span class="hljs-params">observer</span>) &#123;          
     <span class="hljs-variable language_">this</span>.<span class="hljs-property">observers</span>.<span class="hljs-title function_">push</span>(observer)<span class="hljs-comment">//往观察者队列添加观察者    </span>
 &#125;    
 <span class="hljs-title function_">notify</span>(<span class="hljs-params"></span>) &#123;                       <span class="hljs-comment">//通知所有观察者,实际上是把观察者的update()都执行了一遍       </span>
     <span class="hljs-variable language_">this</span>.<span class="hljs-property">observers</span>.<span class="hljs-title function_">forEach</span>(<span class="hljs-function"><span class="hljs-params">observer</span> =&gt;</span> &#123;        
         observer.<span class="hljs-title function_">update</span>()            <span class="hljs-comment">//依次取出观察者,并执行观察者的update方法        </span>
     &#125;)    
 &#125;
&#125;

<span class="hljs-keyword">var</span> subject = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Subject</span>()       <span class="hljs-comment">//被观察者</span>
<span class="hljs-keyword">const</span> <span class="hljs-title function_">update</span> = (<span class="hljs-params"></span>) =&gt; &#123;<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(<span class="hljs-string">&#x27;被观察者发出通知&#x27;</span>)&#125;  <span class="hljs-comment">//收到广播时要执行的方法</span>
<span class="hljs-keyword">var</span> ob1 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Observer</span>(update)    <span class="hljs-comment">//观察者1</span>
<span class="hljs-keyword">var</span> ob2 = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Observer</span>(update)    <span class="hljs-comment">//观察者2</span>
subject.<span class="hljs-title function_">addObserver</span>(ob1)          <span class="hljs-comment">//观察者1订阅subject的通知</span>
subject.<span class="hljs-title function_">addObserver</span>(ob2)          <span class="hljs-comment">//观察者2订阅subject的通知</span>
subject.<span class="hljs-title function_">notify</span>()                  <span class="hljs-comment">//发出广播,执行所有观察者的update方法</span></code></pre></div>

<p>有些文章也把观察者模式称为发布订阅模式，其实二者是有所区别的，发布订阅相较于观察者模式多一个调度中心。</p>
<h2 id="5-装饰器模式"><a href="#5-装饰器模式" class="headerlink" title="5. 装饰器模式"></a>5. 装饰器模式</h2><p>装饰器模式，可以理解为对类的一个包装，动态地拓展类的功能，ES7的<code>装饰器语法</code>以及React中的<code>高阶组件（HoC）</code>都是这一模式的实现。react-redux的<code>connect()</code>也运用了装饰器模式，这里以ES7的装饰器为例：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">function</span> <span class="hljs-title function_">info</span>(<span class="hljs-params">target</span>) &#123;
 target.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">name</span> = <span class="hljs-string">&#x27;张三&#x27;</span>
 target.<span class="hljs-property"><span class="hljs-keyword">prototype</span></span>.<span class="hljs-property">age</span> = <span class="hljs-number">10</span>
&#125;

@info
<span class="hljs-keyword">class</span> <span class="hljs-title class_">Man</span> &#123;&#125;

<span class="hljs-keyword">let</span> man = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Man</span>()
man.<span class="hljs-property">name</span> <span class="hljs-comment">// 张三</span></code></pre></div>

<h2 id="6-适配器模式"><a href="#6-适配器模式" class="headerlink" title="6. 适配器模式"></a>6. 适配器模式</h2><p>适配器模式，将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作。我们在生活中就常常有使用适配器的场景，例如出境旅游插头插座不匹配，这时我们就需要使用转换插头，也就是适配器来帮我们解决问题。</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">class</span> <span class="hljs-title class_">Adaptee</span> &#123;
 <span class="hljs-title function_">test</span>(<span class="hljs-params"></span>) &#123;
   <span class="hljs-keyword">return</span> <span class="hljs-string">&#x27;旧接口&#x27;</span>
 &#125;
&#125;

<span class="hljs-keyword">class</span> <span class="hljs-title class_">Target</span> &#123;
  <span class="hljs-title function_">constructor</span>(<span class="hljs-params"></span>) &#123;
      <span class="hljs-variable language_">this</span>.<span class="hljs-property">adaptee</span> = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Adaptee</span>()
  &#125;
  <span class="hljs-title function_">test</span>(<span class="hljs-params"></span>) &#123;
      <span class="hljs-keyword">let</span> info = <span class="hljs-variable language_">this</span>.<span class="hljs-property">adaptee</span>.<span class="hljs-title function_">test</span>()
      <span class="hljs-keyword">return</span> <span class="hljs-string">`适配<span class="hljs-subst">$&#123;info&#125;</span>`</span>
  &#125;
&#125;

<span class="hljs-keyword">let</span> target = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Target</span>()
<span class="hljs-variable language_">console</span>.<span class="hljs-title function_">log</span>(target.<span class="hljs-title function_">test</span>())</code></pre></div>

<h2 id="7-代理模式"><a href="#7-代理模式" class="headerlink" title="7. 代理模式"></a>7. 代理模式</h2><p>代理模式，为一个对象找一个替代对象，以便对原对象进行访问。即在访问者与目标对象之间加一层代理，通过代理做授权和控制。最常见的例子是经纪人代理明星业务，假设你作为一个投资者，想联系明星打广告，那么你就需要先经过代理经纪人，经纪人对你的资质进行考察，并通知你明星排期，替明星本人过滤不必要的信息。<code>事件代理</code>、<code>JQuery的$.proxy</code>、<code>ES6的proxy</code>都是这一模式的实现，下面以ES6的proxy为例：</p>
<div class="code-wrapper"><pre><code class="hljs javascript"><span class="hljs-keyword">const</span> idol = &#123;
 <span class="hljs-attr">name</span>: <span class="hljs-string">&#x27;蔡x抻&#x27;</span>,
 <span class="hljs-attr">phone</span>: <span class="hljs-number">10086</span>,
 <span class="hljs-attr">price</span>: <span class="hljs-number">1000000</span>  <span class="hljs-comment">//报价</span>
&#125;

<span class="hljs-keyword">const</span> agent = <span class="hljs-keyword">new</span> <span class="hljs-title class_">Proxy</span>(idol, &#123;
  <span class="hljs-attr">get</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">target</span>) &#123;
    <span class="hljs-comment">//拦截明星电话的请求,只提供经纪人电话</span>
    <span class="hljs-keyword">return</span> <span class="hljs-string">&#x27;经纪人电话:10010&#x27;</span>
  &#125;,
  <span class="hljs-attr">set</span>: <span class="hljs-keyword">function</span>(<span class="hljs-params">target, key, value</span>) &#123;
    <span class="hljs-keyword">if</span>(key === <span class="hljs-string">&#x27;price&#x27;</span> ) &#123;
      <span class="hljs-comment">//经纪人过滤资质</span>
      <span class="hljs-keyword">if</span>(value &lt; target.<span class="hljs-property">price</span>) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Error</span>(<span class="hljs-string">&#x27;报价过低&#x27;</span>)
      target.<span class="hljs-property">price</span> = value
    &#125;
  &#125;
&#125;)


agent.<span class="hljs-property">phone</span>        <span class="hljs-comment">//经纪人电话:10010</span>
agent.<span class="hljs-property">price</span> = <span class="hljs-number">100</span>  <span class="hljs-comment">//Uncaught Error: 报价过低</span></code></pre></div>

<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/5/171465b92f6ded5e~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<h1 id="HTML相关"><a href="#HTML相关" class="headerlink" title="HTML相关"></a>HTML相关</h1><h2 id="1-说说HTML5在标签、属性、存储、API上的新特性"><a href="#1-说说HTML5在标签、属性、存储、API上的新特性" class="headerlink" title="1. 说说HTML5在标签、属性、存储、API上的新特性"></a>1. 说说HTML5在标签、属性、存储、API上的新特性</h2><p>标签：新增语义化标签（<code>aside / figure / section / header / footer / nav</code>等），增加多媒体标签<code>video</code>和<code>audio</code>，使得样式和结构更加分离<br>属性：增强表单，主要是增强了<code>input</code>的type属性；<code>meta</code>增加charset以设置字符集；<code>script</code>增加async以异步加载脚本<br>存储：增加<code>localStorage</code>、<code>sessionStorage</code>和<code>indexedDB</code>，引入了<code>application cache</code>对web和应用进行缓存<br>API：增加<code>拖放API</code>、<code>地理定位</code>、<code>SVG绘图</code>、<code>canvas绘图</code>、<code>Web Worker</code>、<code>WebSocket</code></p>
<h2 id="2-doctype的作用是什么？"><a href="#2-doctype的作用是什么？" class="headerlink" title="2. doctype的作用是什么？"></a>2. doctype的作用是什么？</h2><p>声明文档类型，告知浏览器用什么文档标准解析这个文档：</p>
<ul>
<li>怪异模式：浏览器使用自己的模式解析文档，不加doctype时默认为怪异模式</li>
<li>标准模式：浏览器以W3C的标准解析文档</li>
</ul>
<h2 id="3-几种前端储存以及它们之间的区别"><a href="#3-几种前端储存以及它们之间的区别" class="headerlink" title="3. 几种前端储存以及它们之间的区别"></a>3. 几种前端储存以及它们之间的区别</h2><ul>
<li><strong>cookies</strong>： HTML5之前本地储存的主要方式，大小只有4k，HTTP请求头会自动带上cookie，兼容性好</li>
<li><strong>localStorage</strong>：HTML5新特性，持久性存储，即使页面关闭也不会被清除，以键值对的方式存储，大小为5M</li>
<li><strong>sessionStorage</strong>：HTML5新特性，操作及大小同localStorage，和localStorage的区别在于sessionStorage在选项卡(页面)被关闭时即清除，且不同选项卡之间的sessionStorage不互通</li>
<li><strong>IndexedDB</strong>： NoSQL型数据库，类比MongoDB，使用键值对进行储存，异步操作数据库，支持事务，储存空间可以在250MB以上，但是IndexedDB受同源策略限制</li>
<li><strong>Web SQL</strong>：是在浏览器上模拟的关系型数据库，开发者可以通过SQL语句来操作Web SQL，是HTML5以外一套独立的规范，兼容性差</li>
</ul>
<h2 id="4-href和src有什么区别"><a href="#4-href和src有什么区别" class="headerlink" title="4. href和src有什么区别"></a>4. href和src有什么区别</h2><p><code>href（hyperReference）</code>即超文本引用：当浏览器遇到href时，会并行的地下载资源，不会阻塞页面解析，例如我们使用<code>&lt;link&gt;</code>引入CSS，浏览器会并行地下载CSS而不阻塞页面解析. 因此我们在引入CSS时建议使用<code>&lt;link&gt;</code>而不是<code>@import</code></p>
<div class="code-wrapper"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">link</span> <span class="hljs-attr">href</span>=<span class="hljs-string">&quot;style.css&quot;</span> <span class="hljs-attr">rel</span>=<span class="hljs-string">&quot;stylesheet&quot;</span> /&gt;</span></code></pre></div>

<p><code>src（resource）</code>即资源，当浏览器遇到src时，会暂停页面解析，直到该资源下载或执行完毕，这也是script标签之所以放底部的原因</p>
<div class="code-wrapper"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">script</span> <span class="hljs-attr">src</span>=<span class="hljs-string">&quot;script.js&quot;</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">script</span>&gt;</span></code></pre></div>

<h2 id="5-meta有哪些属性，作用是什么"><a href="#5-meta有哪些属性，作用是什么" class="headerlink" title="5. meta有哪些属性，作用是什么"></a>5. meta有哪些属性，作用是什么</h2><p>meta标签用于描述网页的<code>元信息</code>，如网站作者、描述、关键词，meta通过<code>name=xxx</code>和<code>content=xxx</code>的形式来定义信息，常用设置如下：</p>
<ul>
<li>charset：定义HTML文档的字符集</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">meta</span> <span class="hljs-attr">charset</span>=<span class="hljs-string">&quot;UTF-8&quot;</span> &gt;</span></code></pre></div>

<ul>
<li>http-equiv：可用于模拟http请求头，可设置过期时间、缓存、刷新</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs html">＜meta http-equiv=&quot;expires&quot; content=&quot;Wed, 20 Jun 2019 22:33:00 GMT&quot;＞</code></pre></div>

<ul>
<li>viewport：视口，用于控制页面宽高及缩放比例</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs html"><span class="hljs-tag">&lt;<span class="hljs-name">meta</span> </span>
<span class="hljs-tag">    <span class="hljs-attr">name</span>=<span class="hljs-string">&quot;viewport&quot;</span> </span>
<span class="hljs-tag">    <span class="hljs-attr">content</span>=<span class="hljs-string">&quot;width=device-width, initial-scale=1, maximum-scale=1&quot;</span></span>
<span class="hljs-tag">&gt;</span></code></pre></div>

<h2 id="6-viewport有哪些参数，作用是什么"><a href="#6-viewport有哪些参数，作用是什么" class="headerlink" title="6. viewport有哪些参数，作用是什么"></a>6. viewport有哪些参数，作用是什么</h2><ul>
<li><p>width&#x2F;height，宽高，默认宽度980px</p>
</li>
<li><p>initial-scale，初始缩放比例，1~10</p>
</li>
<li><p>maximum-scale&#x2F;minimum-scale，允许用户缩放的最大&#x2F;小比例</p>
</li>
<li><p>user-scalable，用户是否可以缩放 (yes&#x2F;no)</p>
</li>
</ul>
<h2 id="7-http-equive属性的作用和参数"><a href="#7-http-equive属性的作用和参数" class="headerlink" title="7. http-equive属性的作用和参数"></a>7. http-equive属性的作用和参数</h2><ul>
<li><strong>expires</strong>：指定过期时间</li>
<li><strong>progma</strong>：设置no-cache可以禁止缓存</li>
<li><strong>refresh</strong>：定时刷新</li>
<li><strong>set-cookie</strong>：可以设置cookie</li>
<li><strong>X-UA-Compatible</strong>：使用浏览器版本</li>
<li><strong>apple-mobile-web-app-status-bar-style</strong>：针对WebApp全屏模式，隐藏状态栏&#x2F;设置状态栏颜色</li>
</ul>
<h1 id="CSS相关"><a href="#CSS相关" class="headerlink" title="CSS相关"></a>CSS相关</h1><h2 id="清除浮动的方法"><a href="#清除浮动的方法" class="headerlink" title="清除浮动的方法"></a>清除浮动的方法</h2><blockquote>
<p>为什么要清除浮动：清除浮动是为了解决子元素浮动而导致父元素高度塌陷的问题</p>
</blockquote>
<h3 id="1-添加新元素"><a href="#1-添加新元素" class="headerlink" title="1. 添加新元素"></a>1. 添加新元素</h3><div class="code-wrapper"><pre><code class="hljs css">&lt;<span class="hljs-selector-tag">div</span> class=&quot;parent&quot;&gt;
  &lt;<span class="hljs-selector-tag">div</span> class=&quot;child&quot;&gt;&lt;/<span class="hljs-selector-tag">div</span>&gt;
  &lt;!-- 添加一个空元素，利用css提供的<span class="hljs-attribute">clear</span>:both清除浮动 --&gt;
  &lt;div style=<span class="hljs-string">&quot;clear: both&quot;</span>&gt;&lt;/div&gt;
&lt;/div&gt;</code></pre></div>

<h3 id="2-使用伪元素"><a href="#2-使用伪元素" class="headerlink" title="2. 使用伪元素"></a>2. 使用伪元素</h3><div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-comment">/* 对父元素添加伪元素 */</span>
<span class="hljs-selector-class">.parent</span><span class="hljs-selector-pseudo">::after</span>&#123;
  <span class="hljs-attribute">content</span>: <span class="hljs-string">&quot;&quot;</span>;
  <span class="hljs-attribute">display</span>: block;
  <span class="hljs-attribute">height</span>: <span class="hljs-number">0</span>;
  <span class="hljs-attribute">clear</span>:both;
&#125;</code></pre></div>

<h3 id="3-触发父元素BFC"><a href="#3-触发父元素BFC" class="headerlink" title="3. 触发父元素BFC"></a>3. 触发父元素BFC</h3><div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-comment">/* 触发父元素BFC */</span>
<span class="hljs-selector-class">.parent</span> &#123;
  <span class="hljs-attribute">overflow</span>: hidden;
  <span class="hljs-comment">/* float: left; */</span>
  <span class="hljs-comment">/* position: absolute; */</span>
  <span class="hljs-comment">/* display: inline-block */</span>
  <span class="hljs-comment">/* 以上属性均可触发BFC */</span>
&#125;</code></pre></div>

<h2 id="介绍一下flex布局"><a href="#介绍一下flex布局" class="headerlink" title="介绍一下flex布局"></a>介绍一下flex布局</h2><p>这一小节也不应该从“flex是什么”开始讲，主轴、侧轴这些概念相信用过flex布局都知道，所以我们直接flex的几个属性讲起：</p>
<h3 id="容器属性（使用在flex布局容器上的属性）"><a href="#容器属性（使用在flex布局容器上的属性）" class="headerlink" title="容器属性（使用在flex布局容器上的属性）"></a>容器属性（使用在flex布局容器上的属性）</h3><ul>
<li><strong>justify-content</strong>：定义了子元素在主轴(横轴)上的对齐方式</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.container</span> &#123;
    <span class="hljs-attribute">justify-content</span>: center | flex-start | flex-end | space-between | space-around;
    <span class="hljs-comment">/* 主轴对齐方式：居中 | 左对齐(默认值) | 右对齐 | 两端对齐(子元素间边距相等) | 周围对齐(每个子元素两侧margin相等） */</span>
&#125;</code></pre></div>

<ul>
<li><strong>align-items</strong>：定义了定义项目在交叉轴(竖轴)上对齐方式</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.container</span> &#123;
    <span class="hljs-attribute">align-items</span>: center | flex-start | flex-end | baseline | stretch;
    <span class="hljs-comment">/* 侧轴对齐方式：居中 | 上对齐 | 下对齐 | 项目的第一行文字的基线对齐 | 如果子元素未设置高度，将占满整个容器的高度（默认值） */</span>
&#125;</code></pre></div>

<ul>
<li><strong>flex-direction</strong>：主轴(横轴)方向</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs javascript">.<span class="hljs-property">container</span> &#123;
    flex-<span class="hljs-attr">direction</span>: row | row-reverse | column | column-reverse;
    <span class="hljs-comment">/* 主轴方向：水平由左至右排列（默认值） | 水平由右向左 | 垂直由上至下 | 垂直由下至上 */</span>
&#125;</code></pre></div>



<ul>
<li><strong>flex-wrap</strong>：换行方式</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.container</span> &#123;
    <span class="hljs-attribute">flex-wrap</span>: nowrap | wrap | wrap-reverse;
    <span class="hljs-comment">/* 换行方式：不换行（默认值） | 换行 | 反向换行 */</span>
&#125;</code></pre></div>

<ul>
<li><strong>flex-flow</strong>：flex-flow属性是flex-direction属性和flex-wrap的简写</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.container</span> &#123;
    <span class="hljs-attribute">flex-flow</span>: &lt;flex-direction&gt; || &lt;flex-wrap&gt;;
    <span class="hljs-comment">/* 默认值：row nowrap */</span>
&#125;</code></pre></div>

<ul>
<li><strong>align-content</strong>：定义多根轴线的对齐方式</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.container</span> &#123;
    <span class="hljs-attribute">align-content</span>: center | flex-start | flex-end | space-between | space-around | stretch;
    <span class="hljs-comment">/* 默认值：与交叉轴的中点对齐 | 与交叉轴的起点对齐 | 与交叉轴的终点对齐 | 与交叉轴两端对齐 | 每根轴线两侧的间隔都相等 | （默认值）：轴线占满整个交叉轴 */</span>
&#125;</code></pre></div>

<h3 id="项目属性（使用在容器内子元素上的属性）"><a href="#项目属性（使用在容器内子元素上的属性）" class="headerlink" title="项目属性（使用在容器内子元素上的属性）"></a>项目属性（使用在容器内子元素上的属性）</h3><ul>
<li><strong>flex-grow</strong>：定义项目的放大比例，默认为0，即使有剩余空间也不放大。如果所有子元素flex-grow为1，那么将等分剩余空间，如果某个子元素flex-grow为2，那么这个子元素将占据2倍的剩余空间</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">flex-grow</span>: &lt;number&gt;; <span class="hljs-comment">/* default 0 */</span>
&#125;</code></pre></div>

<ul>
<li><strong>flex-shrink</strong>：定义项目的缩小比例，默认为1，即如果空间不足，子元素将缩小。如果所有子元素flex-shrink都为1，某个子元素flex-shrink为0，那么该子元素将不缩小</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">flex-shrink</span>: &lt;number&gt;; <span class="hljs-comment">/* default 1 */</span>
&#125;</code></pre></div>

<p><strong>flex-basis</strong>：定义在分配多余空间之前，项目占据的主轴空间，默认auto，即子元素本来的大小，如果设定为一个固定的值，那么子元素将占据固定空间</p>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">flex-basis</span>: &lt;length&gt; | auto; <span class="hljs-comment">/* default auto */</span>
&#125;</code></pre></div>

<ul>
<li><strong>flex</strong>：flex属性是flex-grow, flex-shrink 和 flex-basis的简写，默认值为0 1 auto，即有剩余空间不放大，剩余空间不够将缩小，子元素占据自身大小</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">flex</span>: none | [ &lt;<span class="hljs-string">&#x27;flex-grow&#x27;</span>&gt; &lt;<span class="hljs-string">&#x27;flex-shrink&#x27;</span>&gt;? || &lt;<span class="hljs-string">&#x27;flex-basis&#x27;</span>&gt; ]
&#125;</code></pre></div>

<p>flex有两个快捷值：<code>auto</code>和<code>none</code>，分别代表<code>1 1 auto</code>（有剩余空间则平均分配，空间不够将等比缩小，子元素占据空间等于自身大小）和<code>0 0 auto</code>（有剩余空间也不分配，空间不够也不缩小，子元素占据空间等于自身大小）</p>
<ul>
<li><strong>order</strong>：定义项目的排列顺序。数值越小，排列越靠前，默认为0</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">order</span>: &lt;integer&gt;;
&#125;</code></pre></div>

<ul>
<li><strong>align-self</strong>：定义单个子元素的排列方式，例如align-items设置了center，使得所有子元素居中对齐，那么可以通过给某个子元素设置align-self来单独设置子元素的排序方式</li>
</ul>
<div class="code-wrapper"><pre><code class="hljs css"><span class="hljs-selector-class">.item</span> &#123;
  <span class="hljs-attribute">align-self</span>: auto | flex-start | flex-end | center | baseline | stretch;
&#125;</code></pre></div>

<p>参考资料：<a href="https://link.juejin.cn/?target=http://www.ruanyifeng.com/blog/2015/07/flex-grammar.html">阮一峰Flex布局</a></p>
<h2 id="什么是BFC"><a href="#什么是BFC" class="headerlink" title="什么是BFC"></a>什么是BFC</h2><p>BFC全称 Block Formatting Context 即块级格式上下文，简单的说，BFC是页面上的一个隔离的独立容器，不受外界干扰或干扰外界<br>如何触发BFC</p>
<ul>
<li><code>float</code>不为 none</li>
<li><code>overflow</code>的值不为 visible</li>
<li><code>position</code> 为 absolute 或 fixed</li>
<li><code>display</code>的值为 inline-block 或 table-cell 或 table-caption 或 grid</li>
</ul>
<h2 id="BFC的渲染规则是什么"><a href="#BFC的渲染规则是什么" class="headerlink" title="BFC的渲染规则是什么"></a>BFC的渲染规则是什么</h2><ul>
<li><p>BFC是页面上的一个隔离的独立容器，不受外界干扰或干扰外界</p>
</li>
<li><p>计算BFC的高度时，浮动子元素也参与计算（即内部有浮动元素时也不会发生高度塌陷）</p>
</li>
<li><p>BFC的区域不会与float的元素区域重叠</p>
</li>
<li><p>BFC内部的元素会在垂直方向上放置</p>
</li>
<li><p>BFC内部两个相邻元素的margin会发生重叠</p>
</li>
</ul>
<h2 id="BFC的应用场景"><a href="#BFC的应用场景" class="headerlink" title="BFC的应用场景"></a>BFC的应用场景</h2><ul>
<li><strong>清除浮动</strong>：BFC内部的浮动元素会参与高度计算，因此可用于清除浮动，防止高度塌陷</li>
<li><strong>避免某元素被浮动元素覆盖</strong>：BFC的区域不会与浮动元素的区域重叠</li>
<li><strong>阻止外边距重叠</strong>：属于同一个BFC的两个相邻Box的margin会发生折叠，不同BFC不会发生折叠</li>
</ul>
<p><img src="https://p1-jj.byteimg.com/tos-cn-i-t2oaga2asx/gold-user-assets/2020/4/6/1714e0acba58457f~tplv-t2oaga2asx-zoom-in-crop-mark:3024:0:0:0.awebp" srcset="/blog/img/loading.gif" lazyload></p>
<p>原文链接：<a target="_blank" rel="noopener" href="https://juejin.cn/post/6844904116552990727">2万字 | 前端基础拾遗90问</a> </p>

                
              </div>
            
            <hr/>
            <div>
              <div class="post-metas my-3">
  
    <div class="post-meta mr-3 d-flex align-items-center">
      <i class="iconfont icon-category"></i>
      

<span class="category-chains">
  
  
    
      <span class="category-chain">
        
  <a href="/blog/categories/%E5%89%8D%E7%AB%AF/" class="category-chain-item">前端</a>
  
  

      </span>
    
  
</span>

    </div>
  
  
    <div class="post-meta">
      <i class="iconfont icon-tags"></i>
      
        <a href="/blog/tags/%E5%89%8D%E7%AB%AF/">#前端</a>
      
    </div>
  
</div>


              

              
                <div class="post-prevnext my-3">
                  <article class="post-prev col-6">
                    
                    
                      <a href="/blog/const-for-es5.html" title="如何在 ES5 环境下实现一个const？">
                        <i class="iconfont icon-arrowleft"></i>
                        <span class="hidden-mobile">如何在 ES5 环境下实现一个const？</span>
                        <span class="visible-mobile">上一篇</span>
                      </a>
                    
                  </article>
                  <article class="post-next col-6">
                    
                    
                      <a href="/blog/flex-layout.html" title="flex布局教程">
                        <span class="hidden-mobile">flex布局教程</span>
                        <span class="visible-mobile">下一篇</span>
                        <i class="iconfont icon-arrowright"></i>
                      </a>
                    
                  </article>
                </div>
              
            </div>

            
          </article>
        </div>
      </div>
    </div>

    <div class="side-col d-none d-lg-block col-lg-2">
      
  <aside class="sidebar" style="margin-left: -1rem">
    <div id="toc">
  <p class="toc-header"><i class="iconfont icon-list"></i>&nbsp;目录</p>
  <div class="toc-body" id="toc-body"></div>
</div>



  </aside>


    </div>
  </div>
</div>





  



  



  



  



  







    

    
      <a id="scroll-top-button" aria-label="TOP" href="#" role="button">
        <i class="iconfont icon-arrowup" aria-hidden="true"></i>
      </a>
    

    
      <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v" for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>

    

    
  </main>

  <footer>
    <div class="footer-inner">
  
    <div class="footer-content">
       <span>枫🍁川</span> <i class="iconfont icon-love"></i> <span>前端小白</span> 
    </div>
  
  
    <div class="statistics">
  
  

  
    
      <span id="busuanzi_container_site_pv" style="display: none">
        总访问量 
        <span id="busuanzi_value_site_pv"></span>
         次
      </span>
    
    
      <span id="busuanzi_container_site_uv" style="display: none">
        总访客数 
        <span id="busuanzi_value_site_uv"></span>
         人
      </span>
    
    
  
</div>

  
  
  
</div>
<script type="text/javascript" src="/blog/js/click-love.js"></script>

  </footer>

  <!-- Scripts -->
  
  <script  src="https://lib.baomitu.com/nprogress/0.2.0/nprogress.min.js" ></script>
  <link  rel="stylesheet" href="https://lib.baomitu.com/nprogress/0.2.0/nprogress.min.css" />

  <script>
    NProgress.configure({"showSpinner":false,"trickleSpeed":100})
    NProgress.start()
    window.addEventListener('load', function() {
      NProgress.done();
    })
  </script>


<script  src="https://lib.baomitu.com/jquery/3.6.0/jquery.min.js" ></script>
<script  src="https://lib.baomitu.com/twitter-bootstrap/4.6.1/js/bootstrap.min.js" ></script>
<script  src="/blog/js/events.js" ></script>
<script  src="/blog/js/plugins.js" ></script>


  <script  src="https://lib.baomitu.com/typed.js/2.0.12/typed.min.js" ></script>
  <script>
    (function (window, document) {
      var typing = Fluid.plugins.typing;
      var subtitle = document.getElementById('subtitle');
      if (!subtitle || !typing) {
        return;
      }
      var text = subtitle.getAttribute('data-typed-text');
      
        typing(text);
      
    })(window, document);
  </script>




  
    <script  src="/blog/js/img-lazyload.js" ></script>
  




  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/tocbot/4.18.2/tocbot.min.js', function() {
    var toc = jQuery('#toc');
    if (toc.length === 0 || !window.tocbot) { return; }
    var boardCtn = jQuery('#board-ctn');
    var boardTop = boardCtn.offset().top;

    window.tocbot.init({
      tocSelector     : '#toc-body',
      contentSelector : '.markdown-body',
      headingSelector : CONFIG.toc.headingSelector || 'h1,h2,h3,h4,h5,h6',
      linkClass       : 'tocbot-link',
      activeLinkClass : 'tocbot-active-link',
      listClass       : 'tocbot-list',
      isCollapsedClass: 'tocbot-is-collapsed',
      collapsibleClass: 'tocbot-is-collapsible',
      collapseDepth   : CONFIG.toc.collapseDepth || 0,
      scrollSmooth    : true,
      headingsOffset  : -boardTop
    });
    if (toc.find('.toc-list-item').length > 0) {
      toc.css('visibility', 'visible');
    }
  });
</script>


  <script src=https://lib.baomitu.com/clipboard.js/2.0.10/clipboard.min.js></script>

  <script>Fluid.plugins.codeWidget();</script>


  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/anchor-js/4.3.1/anchor.min.js', function() {
    window.anchors.options = {
      placement: CONFIG.anchorjs.placement,
      visible  : CONFIG.anchorjs.visible
    };
    if (CONFIG.anchorjs.icon) {
      window.anchors.options.icon = CONFIG.anchorjs.icon;
    }
    var el = (CONFIG.anchorjs.element || 'h1,h2,h3,h4,h5,h6').split(',');
    var res = [];
    for (var item of el) {
      res.push('.markdown-body > ' + item.trim());
    }
    if (CONFIG.anchorjs.placement === 'left') {
      window.anchors.options.class = 'anchorjs-link-left';
    }
    window.anchors.add(res.join(', '));
  });
</script>


  
<script>
  Fluid.utils.createScript('https://lib.baomitu.com/fancybox/3.5.7/jquery.fancybox.min.js', function() {
    Fluid.plugins.fancyBox();
  });
</script>


  <script>Fluid.plugins.imageCaption();</script>

  <script  src="/blog/js/local-search.js" ></script>

  <script defer src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js" ></script>





<!-- 主题的启动项，将它保持在最底部 -->
<!-- the boot of the theme, keep it at the bottom -->
<script  src="/blog/js/boot.js" ></script>


  

  <noscript>
    <div class="noscript-warning">博客在允许 JavaScript 运行的环境下浏览效果更佳</div>
  </noscript>
<script src="/blog/live2dw/lib/L2Dwidget.min.js?094cbace49a39548bed64abff5988b05"></script><script>L2Dwidget.init({"pluginRootPath":"live2dw/","pluginJsPath":"lib/","pluginModelPath":"assets/","tagMode":false,"debug":false,"model":{"jsonPath":"/blog/live2dw/assets/chitose.model.json"},"display":{"position":"right","width":150,"height":300},"mobile":{"show":true},"react":{"opacity":0.7},"log":false});</script></body>
</html>
